// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.shop;

import com.fowo.api.common.model.PageSearch;
import java.util.Date;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class ShopProfitReportSearchParamPo extends PageSearch {

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date postedDateLocaleStart;

  /**
   * 最晚日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date postedDateLocaleEnd;

  /**
   * 日期 比较(eq)
   */
  private Date postedDateLocaleEq;
  /**
   * 日期 比较(neq)
   */
  private Date postedDateLocaleNeq;
  /**
   * 日期 比较(gt)
   */
  private Date postedDateLocaleGt;
  /**
   * 日期 比较(gte)
   */
  private Date postedDateLocaleGte;
  /**
   * 日期 比较(lt)
   */
  private Date postedDateLocaleLt;
  /**
   * 日期 比较(lte)
   */
  private Date postedDateLocaleLte;
  /**
   * 日期 比较(contains)
   */
  private Date postedDateLocaleContains;
  /**
   * 日期 比较(notcontains)
   */
  private Date postedDateLocaleNotcontains;
  /**
   * 日期 比较(startswith)
   */
  private Date postedDateLocaleStartswith;
  /**
   * 日期 比较(endswith)
   */
  private Date postedDateLocaleEndswith;
  /**
   * 日期 比较(isnull)
   */
  private Boolean postedDateLocaleIsnull;
  /**
   * 日期 比较(isnotnull)
   */
  private Boolean postedDateLocaleIsnotnull;

  /**
   * 销量
   */
  private Integer totalSalesQuantity;

  /**
   * 最小销量
   */
  private Integer totalSalesQuantityMin;

  /**
   * 最大销量
   */
  private Integer totalSalesQuantityMax;

  /**
   * 销量 比较(eq)
   */
  private Integer totalSalesQuantityEq;
  /**
   * 销量 比较(neq)
   */
  private Integer totalSalesQuantityNeq;
  /**
   * 销量 比较(gt)
   */
  private Integer totalSalesQuantityGt;
  /**
   * 销量 比较(gte)
   */
  private Integer totalSalesQuantityGte;
  /**
   * 销量 比较(lt)
   */
  private Integer totalSalesQuantityLt;
  /**
   * 销量 比较(lte)
   */
  private Integer totalSalesQuantityLte;
  /**
   * 销量 比较(contains)
   */
  private Integer totalSalesQuantityContains;
  /**
   * 销量 比较(notcontains)
   */
  private Integer totalSalesQuantityNotcontains;
  /**
   * 销量 比较(startswith)
   */
  private Integer totalSalesQuantityStartswith;
  /**
   * 销量 比较(endswith)
   */
  private Integer totalSalesQuantityEndswith;
  /**
   * 销量 比较(isnull)
   */
  private Boolean totalSalesQuantityIsnull;
  /**
   * 销量 比较(isnotnull)
   */
  private Boolean totalSalesQuantityIsnotnull;

  /**
   * FBA销量
   */
  private Integer fbaSalesQuantity;

  /**
   * 最小FBA销量
   */
  private Integer fbaSalesQuantityMin;

  /**
   * 最大FBA销量
   */
  private Integer fbaSalesQuantityMax;

  /**
   * FBA销量 比较(eq)
   */
  private Integer fbaSalesQuantityEq;
  /**
   * FBA销量 比较(neq)
   */
  private Integer fbaSalesQuantityNeq;
  /**
   * FBA销量 比较(gt)
   */
  private Integer fbaSalesQuantityGt;
  /**
   * FBA销量 比较(gte)
   */
  private Integer fbaSalesQuantityGte;
  /**
   * FBA销量 比较(lt)
   */
  private Integer fbaSalesQuantityLt;
  /**
   * FBA销量 比较(lte)
   */
  private Integer fbaSalesQuantityLte;
  /**
   * FBA销量 比较(contains)
   */
  private Integer fbaSalesQuantityContains;
  /**
   * FBA销量 比较(notcontains)
   */
  private Integer fbaSalesQuantityNotcontains;
  /**
   * FBA销量 比较(startswith)
   */
  private Integer fbaSalesQuantityStartswith;
  /**
   * FBA销量 比较(endswith)
   */
  private Integer fbaSalesQuantityEndswith;
  /**
   * FBA销量 比较(isnull)
   */
  private Boolean fbaSalesQuantityIsnull;
  /**
   * FBA销量 比较(isnotnull)
   */
  private Boolean fbaSalesQuantityIsnotnull;

  /**
   * FBM销量
   */
  private Integer fbmSalesQuantity;

  /**
   * 最小FBM销量
   */
  private Integer fbmSalesQuantityMin;

  /**
   * 最大FBM销量
   */
  private Integer fbmSalesQuantityMax;

  /**
   * FBM销量 比较(eq)
   */
  private Integer fbmSalesQuantityEq;
  /**
   * FBM销量 比较(neq)
   */
  private Integer fbmSalesQuantityNeq;
  /**
   * FBM销量 比较(gt)
   */
  private Integer fbmSalesQuantityGt;
  /**
   * FBM销量 比较(gte)
   */
  private Integer fbmSalesQuantityGte;
  /**
   * FBM销量 比较(lt)
   */
  private Integer fbmSalesQuantityLt;
  /**
   * FBM销量 比较(lte)
   */
  private Integer fbmSalesQuantityLte;
  /**
   * FBM销量 比较(contains)
   */
  private Integer fbmSalesQuantityContains;
  /**
   * FBM销量 比较(notcontains)
   */
  private Integer fbmSalesQuantityNotcontains;
  /**
   * FBM销量 比较(startswith)
   */
  private Integer fbmSalesQuantityStartswith;
  /**
   * FBM销量 比较(endswith)
   */
  private Integer fbmSalesQuantityEndswith;
  /**
   * FBM销量 比较(isnull)
   */
  private Boolean fbmSalesQuantityIsnull;
  /**
   * FBM销量 比较(isnotnull)
   */
  private Boolean fbmSalesQuantityIsnotnull;

  /**
   * 补（换）货量
   */
  private Integer totalReshipQuantity;

  /**
   * 最小补（换）货量
   */
  private Integer totalReshipQuantityMin;

  /**
   * 最大补（换）货量
   */
  private Integer totalReshipQuantityMax;

  /**
   * 补（换）货量 比较(eq)
   */
  private Integer totalReshipQuantityEq;
  /**
   * 补（换）货量 比较(neq)
   */
  private Integer totalReshipQuantityNeq;
  /**
   * 补（换）货量 比较(gt)
   */
  private Integer totalReshipQuantityGt;
  /**
   * 补（换）货量 比较(gte)
   */
  private Integer totalReshipQuantityGte;
  /**
   * 补（换）货量 比较(lt)
   */
  private Integer totalReshipQuantityLt;
  /**
   * 补（换）货量 比较(lte)
   */
  private Integer totalReshipQuantityLte;
  /**
   * 补（换）货量 比较(contains)
   */
  private Integer totalReshipQuantityContains;
  /**
   * 补（换）货量 比较(notcontains)
   */
  private Integer totalReshipQuantityNotcontains;
  /**
   * 补（换）货量 比较(startswith)
   */
  private Integer totalReshipQuantityStartswith;
  /**
   * 补（换）货量 比较(endswith)
   */
  private Integer totalReshipQuantityEndswith;
  /**
   * 补（换）货量 比较(isnull)
   */
  private Boolean totalReshipQuantityIsnull;
  /**
   * 补（换）货量 比较(isnotnull)
   */
  private Boolean totalReshipQuantityIsnotnull;

  /**
   * FBM补（换）货量
   */
  private Integer reshipFbmProductSalesQuantity;

  /**
   * 最小FBM补（换）货量
   */
  private Integer reshipFbmProductSalesQuantityMin;

  /**
   * 最大FBM补（换）货量
   */
  private Integer reshipFbmProductSalesQuantityMax;

  /**
   * FBM补（换）货量 比较(eq)
   */
  private Integer reshipFbmProductSalesQuantityEq;
  /**
   * FBM补（换）货量 比较(neq)
   */
  private Integer reshipFbmProductSalesQuantityNeq;
  /**
   * FBM补（换）货量 比较(gt)
   */
  private Integer reshipFbmProductSalesQuantityGt;
  /**
   * FBM补（换）货量 比较(gte)
   */
  private Integer reshipFbmProductSalesQuantityGte;
  /**
   * FBM补（换）货量 比较(lt)
   */
  private Integer reshipFbmProductSalesQuantityLt;
  /**
   * FBM补（换）货量 比较(lte)
   */
  private Integer reshipFbmProductSalesQuantityLte;
  /**
   * FBM补（换）货量 比较(contains)
   */
  private Integer reshipFbmProductSalesQuantityContains;
  /**
   * FBM补（换）货量 比较(notcontains)
   */
  private Integer reshipFbmProductSalesQuantityNotcontains;
  /**
   * FBM补（换）货量 比较(startswith)
   */
  private Integer reshipFbmProductSalesQuantityStartswith;
  /**
   * FBM补（换）货量 比较(endswith)
   */
  private Integer reshipFbmProductSalesQuantityEndswith;
  /**
   * FBM补（换）货量 比较(isnull)
   */
  private Boolean reshipFbmProductSalesQuantityIsnull;
  /**
   * FBM补（换）货量 比较(isnotnull)
   */
  private Boolean reshipFbmProductSalesQuantityIsnotnull;

  /**
   * FBM补（换）货退回量
   */
  private Integer reshipFbmProductSaleRefundsQuantity;

  /**
   * 最小FBM补（换）货退回量
   */
  private Integer reshipFbmProductSaleRefundsQuantityMin;

  /**
   * 最大FBM补（换）货退回量
   */
  private Integer reshipFbmProductSaleRefundsQuantityMax;

  /**
   * FBM补（换）货退回量 比较(eq)
   */
  private Integer reshipFbmProductSaleRefundsQuantityEq;
  /**
   * FBM补（换）货退回量 比较(neq)
   */
  private Integer reshipFbmProductSaleRefundsQuantityNeq;
  /**
   * FBM补（换）货退回量 比较(gt)
   */
  private Integer reshipFbmProductSaleRefundsQuantityGt;
  /**
   * FBM补（换）货退回量 比较(gte)
   */
  private Integer reshipFbmProductSaleRefundsQuantityGte;
  /**
   * FBM补（换）货退回量 比较(lt)
   */
  private Integer reshipFbmProductSaleRefundsQuantityLt;
  /**
   * FBM补（换）货退回量 比较(lte)
   */
  private Integer reshipFbmProductSaleRefundsQuantityLte;
  /**
   * FBM补（换）货退回量 比较(contains)
   */
  private Integer reshipFbmProductSaleRefundsQuantityContains;
  /**
   * FBM补（换）货退回量 比较(notcontains)
   */
  private Integer reshipFbmProductSaleRefundsQuantityNotcontains;
  /**
   * FBM补（换）货退回量 比较(startswith)
   */
  private Integer reshipFbmProductSaleRefundsQuantityStartswith;
  /**
   * FBM补（换）货退回量 比较(endswith)
   */
  private Integer reshipFbmProductSaleRefundsQuantityEndswith;
  /**
   * FBM补（换）货退回量 比较(isnull)
   */
  private Boolean reshipFbmProductSaleRefundsQuantityIsnull;
  /**
   * FBM补（换）货退回量 比较(isnotnull)
   */
  private Boolean reshipFbmProductSaleRefundsQuantityIsnotnull;

  /**
   * FBA补（换）货量
   */
  private Integer reshipFbaProductSalesQuantity;

  /**
   * 最小FBA补（换）货量
   */
  private Integer reshipFbaProductSalesQuantityMin;

  /**
   * 最大FBA补（换）货量
   */
  private Integer reshipFbaProductSalesQuantityMax;

  /**
   * FBA补（换）货量 比较(eq)
   */
  private Integer reshipFbaProductSalesQuantityEq;
  /**
   * FBA补（换）货量 比较(neq)
   */
  private Integer reshipFbaProductSalesQuantityNeq;
  /**
   * FBA补（换）货量 比较(gt)
   */
  private Integer reshipFbaProductSalesQuantityGt;
  /**
   * FBA补（换）货量 比较(gte)
   */
  private Integer reshipFbaProductSalesQuantityGte;
  /**
   * FBA补（换）货量 比较(lt)
   */
  private Integer reshipFbaProductSalesQuantityLt;
  /**
   * FBA补（换）货量 比较(lte)
   */
  private Integer reshipFbaProductSalesQuantityLte;
  /**
   * FBA补（换）货量 比较(contains)
   */
  private Integer reshipFbaProductSalesQuantityContains;
  /**
   * FBA补（换）货量 比较(notcontains)
   */
  private Integer reshipFbaProductSalesQuantityNotcontains;
  /**
   * FBA补（换）货量 比较(startswith)
   */
  private Integer reshipFbaProductSalesQuantityStartswith;
  /**
   * FBA补（换）货量 比较(endswith)
   */
  private Integer reshipFbaProductSalesQuantityEndswith;
  /**
   * FBA补（换）货量 比较(isnull)
   */
  private Boolean reshipFbaProductSalesQuantityIsnull;
  /**
   * FBA补（换）货量 比较(isnotnull)
   */
  private Boolean reshipFbaProductSalesQuantityIsnotnull;

  /**
   * FBA补（换）货退回量
   */
  private Integer reshipFbaProductSaleRefundsQuantity;

  /**
   * 最小FBA补（换）货退回量
   */
  private Integer reshipFbaProductSaleRefundsQuantityMin;

  /**
   * 最大FBA补（换）货退回量
   */
  private Integer reshipFbaProductSaleRefundsQuantityMax;

  /**
   * FBA补（换）货退回量 比较(eq)
   */
  private Integer reshipFbaProductSaleRefundsQuantityEq;
  /**
   * FBA补（换）货退回量 比较(neq)
   */
  private Integer reshipFbaProductSaleRefundsQuantityNeq;
  /**
   * FBA补（换）货退回量 比较(gt)
   */
  private Integer reshipFbaProductSaleRefundsQuantityGt;
  /**
   * FBA补（换）货退回量 比较(gte)
   */
  private Integer reshipFbaProductSaleRefundsQuantityGte;
  /**
   * FBA补（换）货退回量 比较(lt)
   */
  private Integer reshipFbaProductSaleRefundsQuantityLt;
  /**
   * FBA补（换）货退回量 比较(lte)
   */
  private Integer reshipFbaProductSaleRefundsQuantityLte;
  /**
   * FBA补（换）货退回量 比较(contains)
   */
  private Integer reshipFbaProductSaleRefundsQuantityContains;
  /**
   * FBA补（换）货退回量 比较(notcontains)
   */
  private Integer reshipFbaProductSaleRefundsQuantityNotcontains;
  /**
   * FBA补（换）货退回量 比较(startswith)
   */
  private Integer reshipFbaProductSaleRefundsQuantityStartswith;
  /**
   * FBA补（换）货退回量 比较(endswith)
   */
  private Integer reshipFbaProductSaleRefundsQuantityEndswith;
  /**
   * FBA补（换）货退回量 比较(isnull)
   */
  private Boolean reshipFbaProductSaleRefundsQuantityIsnull;
  /**
   * FBA补（换）货退回量 比较(isnotnull)
   */
  private Boolean reshipFbaProductSaleRefundsQuantityIsnotnull;

  /**
   * 广告销售额
   */
  private java.math.BigDecimal totalAdsSales;

  /**
   * 最小广告销售额
   */
  private java.math.BigDecimal totalAdsSalesMin;

  /**
   * 最大广告销售额
   */
  private java.math.BigDecimal totalAdsSalesMax;

  /**
   * 广告销售额 比较(eq)
   */
  private java.math.BigDecimal totalAdsSalesEq;
  /**
   * 广告销售额 比较(neq)
   */
  private java.math.BigDecimal totalAdsSalesNeq;
  /**
   * 广告销售额 比较(gt)
   */
  private java.math.BigDecimal totalAdsSalesGt;
  /**
   * 广告销售额 比较(gte)
   */
  private java.math.BigDecimal totalAdsSalesGte;
  /**
   * 广告销售额 比较(lt)
   */
  private java.math.BigDecimal totalAdsSalesLt;
  /**
   * 广告销售额 比较(lte)
   */
  private java.math.BigDecimal totalAdsSalesLte;
  /**
   * 广告销售额 比较(contains)
   */
  private java.math.BigDecimal totalAdsSalesContains;
  /**
   * 广告销售额 比较(notcontains)
   */
  private java.math.BigDecimal totalAdsSalesNotcontains;
  /**
   * 广告销售额 比较(startswith)
   */
  private java.math.BigDecimal totalAdsSalesStartswith;
  /**
   * 广告销售额 比较(endswith)
   */
  private java.math.BigDecimal totalAdsSalesEndswith;
  /**
   * 广告销售额 比较(isnull)
   */
  private Boolean totalAdsSalesIsnull;
  /**
   * 广告销售额 比较(isnotnull)
   */
  private Boolean totalAdsSalesIsnotnull;

  /**
   * sd广告销售额
   */
  private java.math.BigDecimal adsSdSales;

  /**
   * 最小sd广告销售额
   */
  private java.math.BigDecimal adsSdSalesMin;

  /**
   * 最大sd广告销售额
   */
  private java.math.BigDecimal adsSdSalesMax;

  /**
   * sd广告销售额 比较(eq)
   */
  private java.math.BigDecimal adsSdSalesEq;
  /**
   * sd广告销售额 比较(neq)
   */
  private java.math.BigDecimal adsSdSalesNeq;
  /**
   * sd广告销售额 比较(gt)
   */
  private java.math.BigDecimal adsSdSalesGt;
  /**
   * sd广告销售额 比较(gte)
   */
  private java.math.BigDecimal adsSdSalesGte;
  /**
   * sd广告销售额 比较(lt)
   */
  private java.math.BigDecimal adsSdSalesLt;
  /**
   * sd广告销售额 比较(lte)
   */
  private java.math.BigDecimal adsSdSalesLte;
  /**
   * sd广告销售额 比较(contains)
   */
  private java.math.BigDecimal adsSdSalesContains;
  /**
   * sd广告销售额 比较(notcontains)
   */
  private java.math.BigDecimal adsSdSalesNotcontains;
  /**
   * sd广告销售额 比较(startswith)
   */
  private java.math.BigDecimal adsSdSalesStartswith;
  /**
   * sd广告销售额 比较(endswith)
   */
  private java.math.BigDecimal adsSdSalesEndswith;
  /**
   * sd广告销售额 比较(isnull)
   */
  private Boolean adsSdSalesIsnull;
  /**
   * sd广告销售额 比较(isnotnull)
   */
  private Boolean adsSdSalesIsnotnull;

  /**
   * 店铺(模糊搜索)
   */
  private String storeName;

  /**
   * 店铺 比较(eq)
   */
  private String storeNameEq;
  /**
   * 店铺 比较(neq)
   */
  private String storeNameNeq;
  /**
   * 店铺 比较(gt)
   */
  private String storeNameGt;
  /**
   * 店铺 比较(gte)
   */
  private String storeNameGte;
  /**
   * 店铺 比较(lt)
   */
  private String storeNameLt;
  /**
   * 店铺 比较(lte)
   */
  private String storeNameLte;
  /**
   * 店铺 比较(contains)
   */
  private String storeNameContains;
  /**
   * 店铺 比较(notcontains)
   */
  private String storeNameNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private String storeNameStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private String storeNameEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean storeNameIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean storeNameIsnotnull;

  /**
   * sp广告销售额
   */
  private java.math.BigDecimal adsSpSales;

  /**
   * 最小sp广告销售额
   */
  private java.math.BigDecimal adsSpSalesMin;

  /**
   * 最大sp广告销售额
   */
  private java.math.BigDecimal adsSpSalesMax;

  /**
   * sp广告销售额 比较(eq)
   */
  private java.math.BigDecimal adsSpSalesEq;
  /**
   * sp广告销售额 比较(neq)
   */
  private java.math.BigDecimal adsSpSalesNeq;
  /**
   * sp广告销售额 比较(gt)
   */
  private java.math.BigDecimal adsSpSalesGt;
  /**
   * sp广告销售额 比较(gte)
   */
  private java.math.BigDecimal adsSpSalesGte;
  /**
   * sp广告销售额 比较(lt)
   */
  private java.math.BigDecimal adsSpSalesLt;
  /**
   * sp广告销售额 比较(lte)
   */
  private java.math.BigDecimal adsSpSalesLte;
  /**
   * sp广告销售额 比较(contains)
   */
  private java.math.BigDecimal adsSpSalesContains;
  /**
   * sp广告销售额 比较(notcontains)
   */
  private java.math.BigDecimal adsSpSalesNotcontains;
  /**
   * sp广告销售额 比较(startswith)
   */
  private java.math.BigDecimal adsSpSalesStartswith;
  /**
   * sp广告销售额 比较(endswith)
   */
  private java.math.BigDecimal adsSpSalesEndswith;
  /**
   * sp广告销售额 比较(isnull)
   */
  private Boolean adsSpSalesIsnull;
  /**
   * sp广告销售额 比较(isnotnull)
   */
  private Boolean adsSpSalesIsnotnull;

  /**
   * sb广告销售额
   */
  private java.math.BigDecimal sharedAdsSbSales;

  /**
   * 最小sb广告销售额
   */
  private java.math.BigDecimal sharedAdsSbSalesMin;

  /**
   * 最大sb广告销售额
   */
  private java.math.BigDecimal sharedAdsSbSalesMax;

  /**
   * sb广告销售额 比较(eq)
   */
  private java.math.BigDecimal sharedAdsSbSalesEq;
  /**
   * sb广告销售额 比较(neq)
   */
  private java.math.BigDecimal sharedAdsSbSalesNeq;
  /**
   * sb广告销售额 比较(gt)
   */
  private java.math.BigDecimal sharedAdsSbSalesGt;
  /**
   * sb广告销售额 比较(gte)
   */
  private java.math.BigDecimal sharedAdsSbSalesGte;
  /**
   * sb广告销售额 比较(lt)
   */
  private java.math.BigDecimal sharedAdsSbSalesLt;
  /**
   * sb广告销售额 比较(lte)
   */
  private java.math.BigDecimal sharedAdsSbSalesLte;
  /**
   * sb广告销售额 比较(contains)
   */
  private java.math.BigDecimal sharedAdsSbSalesContains;
  /**
   * sb广告销售额 比较(notcontains)
   */
  private java.math.BigDecimal sharedAdsSbSalesNotcontains;
  /**
   * sb广告销售额 比较(startswith)
   */
  private java.math.BigDecimal sharedAdsSbSalesStartswith;
  /**
   * sb广告销售额 比较(endswith)
   */
  private java.math.BigDecimal sharedAdsSbSalesEndswith;
  /**
   * sb广告销售额 比较(isnull)
   */
  private Boolean sharedAdsSbSalesIsnull;
  /**
   * sb广告销售额 比较(isnotnull)
   */
  private Boolean sharedAdsSbSalesIsnotnull;

  /**
   * sbv广告销售额
   */
  private java.math.BigDecimal sharedAdsSbvSales;

  /**
   * 最小sbv广告销售额
   */
  private java.math.BigDecimal sharedAdsSbvSalesMin;

  /**
   * 最大sbv广告销售额
   */
  private java.math.BigDecimal sharedAdsSbvSalesMax;

  /**
   * sbv广告销售额 比较(eq)
   */
  private java.math.BigDecimal sharedAdsSbvSalesEq;
  /**
   * sbv广告销售额 比较(neq)
   */
  private java.math.BigDecimal sharedAdsSbvSalesNeq;
  /**
   * sbv广告销售额 比较(gt)
   */
  private java.math.BigDecimal sharedAdsSbvSalesGt;
  /**
   * sbv广告销售额 比较(gte)
   */
  private java.math.BigDecimal sharedAdsSbvSalesGte;
  /**
   * sbv广告销售额 比较(lt)
   */
  private java.math.BigDecimal sharedAdsSbvSalesLt;
  /**
   * sbv广告销售额 比较(lte)
   */
  private java.math.BigDecimal sharedAdsSbvSalesLte;
  /**
   * sbv广告销售额 比较(contains)
   */
  private java.math.BigDecimal sharedAdsSbvSalesContains;
  /**
   * sbv广告销售额 比较(notcontains)
   */
  private java.math.BigDecimal sharedAdsSbvSalesNotcontains;
  /**
   * sbv广告销售额 比较(startswith)
   */
  private java.math.BigDecimal sharedAdsSbvSalesStartswith;
  /**
   * sbv广告销售额 比较(endswith)
   */
  private java.math.BigDecimal sharedAdsSbvSalesEndswith;
  /**
   * sbv广告销售额 比较(isnull)
   */
  private Boolean sharedAdsSbvSalesIsnull;
  /**
   * sbv广告销售额 比较(isnotnull)
   */
  private Boolean sharedAdsSbvSalesIsnotnull;

  /**
   * 广告销量
   */
  private Integer totalAdsSalesQuantity;

  /**
   * 最小广告销量
   */
  private Integer totalAdsSalesQuantityMin;

  /**
   * 最大广告销量
   */
  private Integer totalAdsSalesQuantityMax;

  /**
   * 广告销量 比较(eq)
   */
  private Integer totalAdsSalesQuantityEq;
  /**
   * 广告销量 比较(neq)
   */
  private Integer totalAdsSalesQuantityNeq;
  /**
   * 广告销量 比较(gt)
   */
  private Integer totalAdsSalesQuantityGt;
  /**
   * 广告销量 比较(gte)
   */
  private Integer totalAdsSalesQuantityGte;
  /**
   * 广告销量 比较(lt)
   */
  private Integer totalAdsSalesQuantityLt;
  /**
   * 广告销量 比较(lte)
   */
  private Integer totalAdsSalesQuantityLte;
  /**
   * 广告销量 比较(contains)
   */
  private Integer totalAdsSalesQuantityContains;
  /**
   * 广告销量 比较(notcontains)
   */
  private Integer totalAdsSalesQuantityNotcontains;
  /**
   * 广告销量 比较(startswith)
   */
  private Integer totalAdsSalesQuantityStartswith;
  /**
   * 广告销量 比较(endswith)
   */
  private Integer totalAdsSalesQuantityEndswith;
  /**
   * 广告销量 比较(isnull)
   */
  private Boolean totalAdsSalesQuantityIsnull;
  /**
   * 广告销量 比较(isnotnull)
   */
  private Boolean totalAdsSalesQuantityIsnotnull;

  /**
   * sd广告销量
   */
  private Integer adsSdSalesQuantity;

  /**
   * 最小sd广告销量
   */
  private Integer adsSdSalesQuantityMin;

  /**
   * 最大sd广告销量
   */
  private Integer adsSdSalesQuantityMax;

  /**
   * sd广告销量 比较(eq)
   */
  private Integer adsSdSalesQuantityEq;
  /**
   * sd广告销量 比较(neq)
   */
  private Integer adsSdSalesQuantityNeq;
  /**
   * sd广告销量 比较(gt)
   */
  private Integer adsSdSalesQuantityGt;
  /**
   * sd广告销量 比较(gte)
   */
  private Integer adsSdSalesQuantityGte;
  /**
   * sd广告销量 比较(lt)
   */
  private Integer adsSdSalesQuantityLt;
  /**
   * sd广告销量 比较(lte)
   */
  private Integer adsSdSalesQuantityLte;
  /**
   * sd广告销量 比较(contains)
   */
  private Integer adsSdSalesQuantityContains;
  /**
   * sd广告销量 比较(notcontains)
   */
  private Integer adsSdSalesQuantityNotcontains;
  /**
   * sd广告销量 比较(startswith)
   */
  private Integer adsSdSalesQuantityStartswith;
  /**
   * sd广告销量 比较(endswith)
   */
  private Integer adsSdSalesQuantityEndswith;
  /**
   * sd广告销量 比较(isnull)
   */
  private Boolean adsSdSalesQuantityIsnull;
  /**
   * sd广告销量 比较(isnotnull)
   */
  private Boolean adsSdSalesQuantityIsnotnull;

  /**
   * sp广告销量
   */
  private Integer adsSpSalesQuantity;

  /**
   * 最小sp广告销量
   */
  private Integer adsSpSalesQuantityMin;

  /**
   * 最大sp广告销量
   */
  private Integer adsSpSalesQuantityMax;

  /**
   * sp广告销量 比较(eq)
   */
  private Integer adsSpSalesQuantityEq;
  /**
   * sp广告销量 比较(neq)
   */
  private Integer adsSpSalesQuantityNeq;
  /**
   * sp广告销量 比较(gt)
   */
  private Integer adsSpSalesQuantityGt;
  /**
   * sp广告销量 比较(gte)
   */
  private Integer adsSpSalesQuantityGte;
  /**
   * sp广告销量 比较(lt)
   */
  private Integer adsSpSalesQuantityLt;
  /**
   * sp广告销量 比较(lte)
   */
  private Integer adsSpSalesQuantityLte;
  /**
   * sp广告销量 比较(contains)
   */
  private Integer adsSpSalesQuantityContains;
  /**
   * sp广告销量 比较(notcontains)
   */
  private Integer adsSpSalesQuantityNotcontains;
  /**
   * sp广告销量 比较(startswith)
   */
  private Integer adsSpSalesQuantityStartswith;
  /**
   * sp广告销量 比较(endswith)
   */
  private Integer adsSpSalesQuantityEndswith;
  /**
   * sp广告销量 比较(isnull)
   */
  private Boolean adsSpSalesQuantityIsnull;
  /**
   * sp广告销量 比较(isnotnull)
   */
  private Boolean adsSpSalesQuantityIsnotnull;

  /**
   * sb广告销量
   */
  private Integer sharedAdsSbSalesQuantity;

  /**
   * 最小sb广告销量
   */
  private Integer sharedAdsSbSalesQuantityMin;

  /**
   * 最大sb广告销量
   */
  private Integer sharedAdsSbSalesQuantityMax;

  /**
   * sb广告销量 比较(eq)
   */
  private Integer sharedAdsSbSalesQuantityEq;
  /**
   * sb广告销量 比较(neq)
   */
  private Integer sharedAdsSbSalesQuantityNeq;
  /**
   * sb广告销量 比较(gt)
   */
  private Integer sharedAdsSbSalesQuantityGt;
  /**
   * sb广告销量 比较(gte)
   */
  private Integer sharedAdsSbSalesQuantityGte;
  /**
   * sb广告销量 比较(lt)
   */
  private Integer sharedAdsSbSalesQuantityLt;
  /**
   * sb广告销量 比较(lte)
   */
  private Integer sharedAdsSbSalesQuantityLte;
  /**
   * sb广告销量 比较(contains)
   */
  private Integer sharedAdsSbSalesQuantityContains;
  /**
   * sb广告销量 比较(notcontains)
   */
  private Integer sharedAdsSbSalesQuantityNotcontains;
  /**
   * sb广告销量 比较(startswith)
   */
  private Integer sharedAdsSbSalesQuantityStartswith;
  /**
   * sb广告销量 比较(endswith)
   */
  private Integer sharedAdsSbSalesQuantityEndswith;
  /**
   * sb广告销量 比较(isnull)
   */
  private Boolean sharedAdsSbSalesQuantityIsnull;
  /**
   * sb广告销量 比较(isnotnull)
   */
  private Boolean sharedAdsSbSalesQuantityIsnotnull;

  /**
   * sbv广告销量
   */
  private Integer sharedAdsSbvSalesQuantity;

  /**
   * 最小sbv广告销量
   */
  private Integer sharedAdsSbvSalesQuantityMin;

  /**
   * 最大sbv广告销量
   */
  private Integer sharedAdsSbvSalesQuantityMax;

  /**
   * sbv广告销量 比较(eq)
   */
  private Integer sharedAdsSbvSalesQuantityEq;
  /**
   * sbv广告销量 比较(neq)
   */
  private Integer sharedAdsSbvSalesQuantityNeq;
  /**
   * sbv广告销量 比较(gt)
   */
  private Integer sharedAdsSbvSalesQuantityGt;
  /**
   * sbv广告销量 比较(gte)
   */
  private Integer sharedAdsSbvSalesQuantityGte;
  /**
   * sbv广告销量 比较(lt)
   */
  private Integer sharedAdsSbvSalesQuantityLt;
  /**
   * sbv广告销量 比较(lte)
   */
  private Integer sharedAdsSbvSalesQuantityLte;
  /**
   * sbv广告销量 比较(contains)
   */
  private Integer sharedAdsSbvSalesQuantityContains;
  /**
   * sbv广告销量 比较(notcontains)
   */
  private Integer sharedAdsSbvSalesQuantityNotcontains;
  /**
   * sbv广告销量 比较(startswith)
   */
  private Integer sharedAdsSbvSalesQuantityStartswith;
  /**
   * sbv广告销量 比较(endswith)
   */
  private Integer sharedAdsSbvSalesQuantityEndswith;
  /**
   * sbv广告销量 比较(isnull)
   */
  private Boolean sharedAdsSbvSalesQuantityIsnull;
  /**
   * sbv广告销量 比较(isnotnull)
   */
  private Boolean sharedAdsSbvSalesQuantityIsnotnull;

  /**
   * 销售额
   */
  private java.math.BigDecimal totalSalesAmount;

  /**
   * 最小销售额
   */
  private java.math.BigDecimal totalSalesAmountMin;

  /**
   * 最大销售额
   */
  private java.math.BigDecimal totalSalesAmountMax;

  /**
   * 销售额 比较(eq)
   */
  private java.math.BigDecimal totalSalesAmountEq;
  /**
   * 销售额 比较(neq)
   */
  private java.math.BigDecimal totalSalesAmountNeq;
  /**
   * 销售额 比较(gt)
   */
  private java.math.BigDecimal totalSalesAmountGt;
  /**
   * 销售额 比较(gte)
   */
  private java.math.BigDecimal totalSalesAmountGte;
  /**
   * 销售额 比较(lt)
   */
  private java.math.BigDecimal totalSalesAmountLt;
  /**
   * 销售额 比较(lte)
   */
  private java.math.BigDecimal totalSalesAmountLte;
  /**
   * 销售额 比较(contains)
   */
  private java.math.BigDecimal totalSalesAmountContains;
  /**
   * 销售额 比较(notcontains)
   */
  private java.math.BigDecimal totalSalesAmountNotcontains;
  /**
   * 销售额 比较(startswith)
   */
  private java.math.BigDecimal totalSalesAmountStartswith;
  /**
   * 销售额 比较(endswith)
   */
  private java.math.BigDecimal totalSalesAmountEndswith;
  /**
   * 销售额 比较(isnull)
   */
  private Boolean totalSalesAmountIsnull;
  /**
   * 销售额 比较(isnotnull)
   */
  private Boolean totalSalesAmountIsnotnull;

  /**
   * FBA销售额
   */
  private java.math.BigDecimal fbaSaleAmount;

  /**
   * 最小FBA销售额
   */
  private java.math.BigDecimal fbaSaleAmountMin;

  /**
   * 最大FBA销售额
   */
  private java.math.BigDecimal fbaSaleAmountMax;

  /**
   * FBA销售额 比较(eq)
   */
  private java.math.BigDecimal fbaSaleAmountEq;
  /**
   * FBA销售额 比较(neq)
   */
  private java.math.BigDecimal fbaSaleAmountNeq;
  /**
   * FBA销售额 比较(gt)
   */
  private java.math.BigDecimal fbaSaleAmountGt;
  /**
   * FBA销售额 比较(gte)
   */
  private java.math.BigDecimal fbaSaleAmountGte;
  /**
   * FBA销售额 比较(lt)
   */
  private java.math.BigDecimal fbaSaleAmountLt;
  /**
   * FBA销售额 比较(lte)
   */
  private java.math.BigDecimal fbaSaleAmountLte;
  /**
   * FBA销售额 比较(contains)
   */
  private java.math.BigDecimal fbaSaleAmountContains;
  /**
   * FBA销售额 比较(notcontains)
   */
  private java.math.BigDecimal fbaSaleAmountNotcontains;
  /**
   * FBA销售额 比较(startswith)
   */
  private java.math.BigDecimal fbaSaleAmountStartswith;
  /**
   * FBA销售额 比较(endswith)
   */
  private java.math.BigDecimal fbaSaleAmountEndswith;
  /**
   * FBA销售额 比较(isnull)
   */
  private Boolean fbaSaleAmountIsnull;
  /**
   * FBA销售额 比较(isnotnull)
   */
  private Boolean fbaSaleAmountIsnotnull;

  /**
   * FBM销售额
   */
  private java.math.BigDecimal fbmSaleAmount;

  /**
   * 最小FBM销售额
   */
  private java.math.BigDecimal fbmSaleAmountMin;

  /**
   * 最大FBM销售额
   */
  private java.math.BigDecimal fbmSaleAmountMax;

  /**
   * FBM销售额 比较(eq)
   */
  private java.math.BigDecimal fbmSaleAmountEq;
  /**
   * FBM销售额 比较(neq)
   */
  private java.math.BigDecimal fbmSaleAmountNeq;
  /**
   * FBM销售额 比较(gt)
   */
  private java.math.BigDecimal fbmSaleAmountGt;
  /**
   * FBM销售额 比较(gte)
   */
  private java.math.BigDecimal fbmSaleAmountGte;
  /**
   * FBM销售额 比较(lt)
   */
  private java.math.BigDecimal fbmSaleAmountLt;
  /**
   * FBM销售额 比较(lte)
   */
  private java.math.BigDecimal fbmSaleAmountLte;
  /**
   * FBM销售额 比较(contains)
   */
  private java.math.BigDecimal fbmSaleAmountContains;
  /**
   * FBM销售额 比较(notcontains)
   */
  private java.math.BigDecimal fbmSaleAmountNotcontains;
  /**
   * FBM销售额 比较(startswith)
   */
  private java.math.BigDecimal fbmSaleAmountStartswith;
  /**
   * FBM销售额 比较(endswith)
   */
  private java.math.BigDecimal fbmSaleAmountEndswith;
  /**
   * FBM销售额 比较(isnull)
   */
  private Boolean fbmSaleAmountIsnull;
  /**
   * FBM销售额 比较(isnotnull)
   */
  private Boolean fbmSaleAmountIsnotnull;

  /**
   * 多渠道销量
   */
  private Integer mcFbaFulfillmentFeesQuantity;

  /**
   * 最小多渠道销量
   */
  private Integer mcFbaFulfillmentFeesQuantityMin;

  /**
   * 最大多渠道销量
   */
  private Integer mcFbaFulfillmentFeesQuantityMax;

  /**
   * 多渠道销量 比较(eq)
   */
  private Integer mcFbaFulfillmentFeesQuantityEq;
  /**
   * 多渠道销量 比较(neq)
   */
  private Integer mcFbaFulfillmentFeesQuantityNeq;
  /**
   * 多渠道销量 比较(gt)
   */
  private Integer mcFbaFulfillmentFeesQuantityGt;
  /**
   * 多渠道销量 比较(gte)
   */
  private Integer mcFbaFulfillmentFeesQuantityGte;
  /**
   * 多渠道销量 比较(lt)
   */
  private Integer mcFbaFulfillmentFeesQuantityLt;
  /**
   * 多渠道销量 比较(lte)
   */
  private Integer mcFbaFulfillmentFeesQuantityLte;
  /**
   * 多渠道销量 比较(contains)
   */
  private Integer mcFbaFulfillmentFeesQuantityContains;
  /**
   * 多渠道销量 比较(notcontains)
   */
  private Integer mcFbaFulfillmentFeesQuantityNotcontains;
  /**
   * 多渠道销量 比较(startswith)
   */
  private Integer mcFbaFulfillmentFeesQuantityStartswith;
  /**
   * 多渠道销量 比较(endswith)
   */
  private Integer mcFbaFulfillmentFeesQuantityEndswith;
  /**
   * 多渠道销量 比较(isnull)
   */
  private Boolean mcFbaFulfillmentFeesQuantityIsnull;
  /**
   * 多渠道销量 比较(isnotnull)
   */
  private Boolean mcFbaFulfillmentFeesQuantityIsnotnull;

  /**
   * 买家运费
   */
  private java.math.BigDecimal shippingCredits;

  /**
   * 最小买家运费
   */
  private java.math.BigDecimal shippingCreditsMin;

  /**
   * 最大买家运费
   */
  private java.math.BigDecimal shippingCreditsMax;

  /**
   * 买家运费 比较(eq)
   */
  private java.math.BigDecimal shippingCreditsEq;
  /**
   * 买家运费 比较(neq)
   */
  private java.math.BigDecimal shippingCreditsNeq;
  /**
   * 买家运费 比较(gt)
   */
  private java.math.BigDecimal shippingCreditsGt;
  /**
   * 买家运费 比较(gte)
   */
  private java.math.BigDecimal shippingCreditsGte;
  /**
   * 买家运费 比较(lt)
   */
  private java.math.BigDecimal shippingCreditsLt;
  /**
   * 买家运费 比较(lte)
   */
  private java.math.BigDecimal shippingCreditsLte;
  /**
   * 买家运费 比较(contains)
   */
  private java.math.BigDecimal shippingCreditsContains;
  /**
   * 买家运费 比较(notcontains)
   */
  private java.math.BigDecimal shippingCreditsNotcontains;
  /**
   * 买家运费 比较(startswith)
   */
  private java.math.BigDecimal shippingCreditsStartswith;
  /**
   * 买家运费 比较(endswith)
   */
  private java.math.BigDecimal shippingCreditsEndswith;
  /**
   * 买家运费 比较(isnull)
   */
  private Boolean shippingCreditsIsnull;
  /**
   * 买家运费 比较(isnotnull)
   */
  private Boolean shippingCreditsIsnotnull;

  /**
   * 促销折扣
   */
  private java.math.BigDecimal promotionalRebates;

  /**
   * 最小促销折扣
   */
  private java.math.BigDecimal promotionalRebatesMin;

  /**
   * 最大促销折扣
   */
  private java.math.BigDecimal promotionalRebatesMax;

  /**
   * 促销折扣 比较(eq)
   */
  private java.math.BigDecimal promotionalRebatesEq;
  /**
   * 促销折扣 比较(neq)
   */
  private java.math.BigDecimal promotionalRebatesNeq;
  /**
   * 促销折扣 比较(gt)
   */
  private java.math.BigDecimal promotionalRebatesGt;
  /**
   * 促销折扣 比较(gte)
   */
  private java.math.BigDecimal promotionalRebatesGte;
  /**
   * 促销折扣 比较(lt)
   */
  private java.math.BigDecimal promotionalRebatesLt;
  /**
   * 促销折扣 比较(lte)
   */
  private java.math.BigDecimal promotionalRebatesLte;
  /**
   * 促销折扣 比较(contains)
   */
  private java.math.BigDecimal promotionalRebatesContains;
  /**
   * 促销折扣 比较(notcontains)
   */
  private java.math.BigDecimal promotionalRebatesNotcontains;
  /**
   * 促销折扣 比较(startswith)
   */
  private java.math.BigDecimal promotionalRebatesStartswith;
  /**
   * 促销折扣 比较(endswith)
   */
  private java.math.BigDecimal promotionalRebatesEndswith;
  /**
   * 促销折扣 比较(isnull)
   */
  private Boolean promotionalRebatesIsnull;
  /**
   * 促销折扣 比较(isnotnull)
   */
  private Boolean promotionalRebatesIsnotnull;

  /**
   * FBA库存赔偿
   */
  private java.math.BigDecimal fbaInventoryCredit;

  /**
   * 最小FBA库存赔偿
   */
  private java.math.BigDecimal fbaInventoryCreditMin;

  /**
   * 最大FBA库存赔偿
   */
  private java.math.BigDecimal fbaInventoryCreditMax;

  /**
   * FBA库存赔偿 比较(eq)
   */
  private java.math.BigDecimal fbaInventoryCreditEq;
  /**
   * FBA库存赔偿 比较(neq)
   */
  private java.math.BigDecimal fbaInventoryCreditNeq;
  /**
   * FBA库存赔偿 比较(gt)
   */
  private java.math.BigDecimal fbaInventoryCreditGt;
  /**
   * FBA库存赔偿 比较(gte)
   */
  private java.math.BigDecimal fbaInventoryCreditGte;
  /**
   * FBA库存赔偿 比较(lt)
   */
  private java.math.BigDecimal fbaInventoryCreditLt;
  /**
   * FBA库存赔偿 比较(lte)
   */
  private java.math.BigDecimal fbaInventoryCreditLte;
  /**
   * FBA库存赔偿 比较(contains)
   */
  private java.math.BigDecimal fbaInventoryCreditContains;
  /**
   * FBA库存赔偿 比较(notcontains)
   */
  private java.math.BigDecimal fbaInventoryCreditNotcontains;
  /**
   * FBA库存赔偿 比较(startswith)
   */
  private java.math.BigDecimal fbaInventoryCreditStartswith;
  /**
   * FBA库存赔偿 比较(endswith)
   */
  private java.math.BigDecimal fbaInventoryCreditEndswith;
  /**
   * FBA库存赔偿 比较(isnull)
   */
  private Boolean fbaInventoryCreditIsnull;
  /**
   * FBA库存赔偿 比较(isnotnull)
   */
  private Boolean fbaInventoryCreditIsnotnull;

  /**
   * COD
   */
  private java.math.BigDecimal cashOnDelivery;

  /**
   * 最小COD
   */
  private java.math.BigDecimal cashOnDeliveryMin;

  /**
   * 最大COD
   */
  private java.math.BigDecimal cashOnDeliveryMax;

  /**
   * COD 比较(eq)
   */
  private java.math.BigDecimal cashOnDeliveryEq;
  /**
   * COD 比较(neq)
   */
  private java.math.BigDecimal cashOnDeliveryNeq;
  /**
   * COD 比较(gt)
   */
  private java.math.BigDecimal cashOnDeliveryGt;
  /**
   * COD 比较(gte)
   */
  private java.math.BigDecimal cashOnDeliveryGte;
  /**
   * COD 比较(lt)
   */
  private java.math.BigDecimal cashOnDeliveryLt;
  /**
   * COD 比较(lte)
   */
  private java.math.BigDecimal cashOnDeliveryLte;
  /**
   * COD 比较(contains)
   */
  private java.math.BigDecimal cashOnDeliveryContains;
  /**
   * COD 比较(notcontains)
   */
  private java.math.BigDecimal cashOnDeliveryNotcontains;
  /**
   * COD 比较(startswith)
   */
  private java.math.BigDecimal cashOnDeliveryStartswith;
  /**
   * COD 比较(endswith)
   */
  private java.math.BigDecimal cashOnDeliveryEndswith;
  /**
   * COD 比较(isnull)
   */
  private Boolean cashOnDeliveryIsnull;
  /**
   * COD 比较(isnotnull)
   */
  private Boolean cashOnDeliveryIsnotnull;

  /**
   * 其他收入
   */
  private java.math.BigDecimal otherInAmount;

  /**
   * 最小其他收入
   */
  private java.math.BigDecimal otherInAmountMin;

  /**
   * 最大其他收入
   */
  private java.math.BigDecimal otherInAmountMax;

  /**
   * 其他收入 比较(eq)
   */
  private java.math.BigDecimal otherInAmountEq;
  /**
   * 其他收入 比较(neq)
   */
  private java.math.BigDecimal otherInAmountNeq;
  /**
   * 其他收入 比较(gt)
   */
  private java.math.BigDecimal otherInAmountGt;
  /**
   * 其他收入 比较(gte)
   */
  private java.math.BigDecimal otherInAmountGte;
  /**
   * 其他收入 比较(lt)
   */
  private java.math.BigDecimal otherInAmountLt;
  /**
   * 其他收入 比较(lte)
   */
  private java.math.BigDecimal otherInAmountLte;
  /**
   * 其他收入 比较(contains)
   */
  private java.math.BigDecimal otherInAmountContains;
  /**
   * 其他收入 比较(notcontains)
   */
  private java.math.BigDecimal otherInAmountNotcontains;
  /**
   * 其他收入 比较(startswith)
   */
  private java.math.BigDecimal otherInAmountStartswith;
  /**
   * 其他收入 比较(endswith)
   */
  private java.math.BigDecimal otherInAmountEndswith;
  /**
   * 其他收入 比较(isnull)
   */
  private Boolean otherInAmountIsnull;
  /**
   * 其他收入 比较(isnotnull)
   */
  private Boolean otherInAmountIsnotnull;

  /**
   * 清算收入
   */
  private java.math.BigDecimal fbaLiquidationProceeds;

  /**
   * 最小清算收入
   */
  private java.math.BigDecimal fbaLiquidationProceedsMin;

  /**
   * 最大清算收入
   */
  private java.math.BigDecimal fbaLiquidationProceedsMax;

  /**
   * 清算收入 比较(eq)
   */
  private java.math.BigDecimal fbaLiquidationProceedsEq;
  /**
   * 清算收入 比较(neq)
   */
  private java.math.BigDecimal fbaLiquidationProceedsNeq;
  /**
   * 清算收入 比较(gt)
   */
  private java.math.BigDecimal fbaLiquidationProceedsGt;
  /**
   * 清算收入 比较(gte)
   */
  private java.math.BigDecimal fbaLiquidationProceedsGte;
  /**
   * 清算收入 比较(lt)
   */
  private java.math.BigDecimal fbaLiquidationProceedsLt;
  /**
   * 清算收入 比较(lte)
   */
  private java.math.BigDecimal fbaLiquidationProceedsLte;
  /**
   * 清算收入 比较(contains)
   */
  private java.math.BigDecimal fbaLiquidationProceedsContains;
  /**
   * 清算收入 比较(notcontains)
   */
  private java.math.BigDecimal fbaLiquidationProceedsNotcontains;
  /**
   * 清算收入 比较(startswith)
   */
  private java.math.BigDecimal fbaLiquidationProceedsStartswith;
  /**
   * 清算收入 比较(endswith)
   */
  private java.math.BigDecimal fbaLiquidationProceedsEndswith;
  /**
   * 清算收入 比较(isnull)
   */
  private Boolean fbaLiquidationProceedsIsnull;
  /**
   * 清算收入 比较(isnotnull)
   */
  private Boolean fbaLiquidationProceedsIsnotnull;

  /**
   * 清算调整
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustments;

  /**
   * 最小清算调整
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsMin;

  /**
   * 最大清算调整
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsMax;

  /**
   * 清算调整 比较(eq)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsEq;
  /**
   * 清算调整 比较(neq)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsNeq;
  /**
   * 清算调整 比较(gt)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsGt;
  /**
   * 清算调整 比较(gte)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsGte;
  /**
   * 清算调整 比较(lt)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsLt;
  /**
   * 清算调整 比较(lte)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsLte;
  /**
   * 清算调整 比较(contains)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsContains;
  /**
   * 清算调整 比较(notcontains)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsNotcontains;
  /**
   * 清算调整 比较(startswith)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsStartswith;
  /**
   * 清算调整 比较(endswith)
   */
  private java.math.BigDecimal fbaLiquidationProceedsAdjustmentsEndswith;
  /**
   * 清算调整 比较(isnull)
   */
  private Boolean fbaLiquidationProceedsAdjustmentsIsnull;
  /**
   * 清算调整 比较(isnotnull)
   */
  private Boolean fbaLiquidationProceedsAdjustmentsIsnotnull;

  /**
   * 亚马逊运费赔偿
   */
  private java.math.BigDecimal amazonShippingReimbursement;

  /**
   * 最小亚马逊运费赔偿
   */
  private java.math.BigDecimal amazonShippingReimbursementMin;

  /**
   * 最大亚马逊运费赔偿
   */
  private java.math.BigDecimal amazonShippingReimbursementMax;

  /**
   * 亚马逊运费赔偿 比较(eq)
   */
  private java.math.BigDecimal amazonShippingReimbursementEq;
  /**
   * 亚马逊运费赔偿 比较(neq)
   */
  private java.math.BigDecimal amazonShippingReimbursementNeq;
  /**
   * 亚马逊运费赔偿 比较(gt)
   */
  private java.math.BigDecimal amazonShippingReimbursementGt;
  /**
   * 亚马逊运费赔偿 比较(gte)
   */
  private java.math.BigDecimal amazonShippingReimbursementGte;
  /**
   * 亚马逊运费赔偿 比较(lt)
   */
  private java.math.BigDecimal amazonShippingReimbursementLt;
  /**
   * 亚马逊运费赔偿 比较(lte)
   */
  private java.math.BigDecimal amazonShippingReimbursementLte;
  /**
   * 亚马逊运费赔偿 比较(contains)
   */
  private java.math.BigDecimal amazonShippingReimbursementContains;
  /**
   * 亚马逊运费赔偿 比较(notcontains)
   */
  private java.math.BigDecimal amazonShippingReimbursementNotcontains;
  /**
   * 亚马逊运费赔偿 比较(startswith)
   */
  private java.math.BigDecimal amazonShippingReimbursementStartswith;
  /**
   * 亚马逊运费赔偿 比较(endswith)
   */
  private java.math.BigDecimal amazonShippingReimbursementEndswith;
  /**
   * 亚马逊运费赔偿 比较(isnull)
   */
  private Boolean amazonShippingReimbursementIsnull;
  /**
   * 亚马逊运费赔偿 比较(isnotnull)
   */
  private Boolean amazonShippingReimbursementIsnotnull;

  /**
   * Safe-T索赔
   */
  private java.math.BigDecimal safeTReimbursement;

  /**
   * 最小Safe-T索赔
   */
  private java.math.BigDecimal safeTReimbursementMin;

  /**
   * 最大Safe-T索赔
   */
  private java.math.BigDecimal safeTReimbursementMax;

  /**
   * Safe-T索赔 比较(eq)
   */
  private java.math.BigDecimal safeTReimbursementEq;
  /**
   * Safe-T索赔 比较(neq)
   */
  private java.math.BigDecimal safeTReimbursementNeq;
  /**
   * Safe-T索赔 比较(gt)
   */
  private java.math.BigDecimal safeTReimbursementGt;
  /**
   * Safe-T索赔 比较(gte)
   */
  private java.math.BigDecimal safeTReimbursementGte;
  /**
   * Safe-T索赔 比较(lt)
   */
  private java.math.BigDecimal safeTReimbursementLt;
  /**
   * Safe-T索赔 比较(lte)
   */
  private java.math.BigDecimal safeTReimbursementLte;
  /**
   * Safe-T索赔 比较(contains)
   */
  private java.math.BigDecimal safeTReimbursementContains;
  /**
   * Safe-T索赔 比较(notcontains)
   */
  private java.math.BigDecimal safeTReimbursementNotcontains;
  /**
   * Safe-T索赔 比较(startswith)
   */
  private java.math.BigDecimal safeTReimbursementStartswith;
  /**
   * Safe-T索赔 比较(endswith)
   */
  private java.math.BigDecimal safeTReimbursementEndswith;
  /**
   * Safe-T索赔 比较(isnull)
   */
  private Boolean safeTReimbursementIsnull;
  /**
   * Safe-T索赔 比较(isnotnull)
   */
  private Boolean safeTReimbursementIsnotnull;

  /**
   * Netco交易
   */
  private java.math.BigDecimal netcoTransaction;

  /**
   * 最小Netco交易
   */
  private java.math.BigDecimal netcoTransactionMin;

  /**
   * 最大Netco交易
   */
  private java.math.BigDecimal netcoTransactionMax;

  /**
   * Netco交易 比较(eq)
   */
  private java.math.BigDecimal netcoTransactionEq;
  /**
   * Netco交易 比较(neq)
   */
  private java.math.BigDecimal netcoTransactionNeq;
  /**
   * Netco交易 比较(gt)
   */
  private java.math.BigDecimal netcoTransactionGt;
  /**
   * Netco交易 比较(gte)
   */
  private java.math.BigDecimal netcoTransactionGte;
  /**
   * Netco交易 比较(lt)
   */
  private java.math.BigDecimal netcoTransactionLt;
  /**
   * Netco交易 比较(lte)
   */
  private java.math.BigDecimal netcoTransactionLte;
  /**
   * Netco交易 比较(contains)
   */
  private java.math.BigDecimal netcoTransactionContains;
  /**
   * Netco交易 比较(notcontains)
   */
  private java.math.BigDecimal netcoTransactionNotcontains;
  /**
   * Netco交易 比较(startswith)
   */
  private java.math.BigDecimal netcoTransactionStartswith;
  /**
   * Netco交易 比较(endswith)
   */
  private java.math.BigDecimal netcoTransactionEndswith;
  /**
   * Netco交易 比较(isnull)
   */
  private Boolean netcoTransactionIsnull;
  /**
   * Netco交易 比较(isnotnull)
   */
  private Boolean netcoTransactionIsnotnull;

  /**
   * 赔偿收入
   */
  private java.math.BigDecimal reimbursements;

  /**
   * 最小赔偿收入
   */
  private java.math.BigDecimal reimbursementsMin;

  /**
   * 最大赔偿收入
   */
  private java.math.BigDecimal reimbursementsMax;

  /**
   * 赔偿收入 比较(eq)
   */
  private java.math.BigDecimal reimbursementsEq;
  /**
   * 赔偿收入 比较(neq)
   */
  private java.math.BigDecimal reimbursementsNeq;
  /**
   * 赔偿收入 比较(gt)
   */
  private java.math.BigDecimal reimbursementsGt;
  /**
   * 赔偿收入 比较(gte)
   */
  private java.math.BigDecimal reimbursementsGte;
  /**
   * 赔偿收入 比较(lt)
   */
  private java.math.BigDecimal reimbursementsLt;
  /**
   * 赔偿收入 比较(lte)
   */
  private java.math.BigDecimal reimbursementsLte;
  /**
   * 赔偿收入 比较(contains)
   */
  private java.math.BigDecimal reimbursementsContains;
  /**
   * 赔偿收入 比较(notcontains)
   */
  private java.math.BigDecimal reimbursementsNotcontains;
  /**
   * 赔偿收入 比较(startswith)
   */
  private java.math.BigDecimal reimbursementsStartswith;
  /**
   * 赔偿收入 比较(endswith)
   */
  private java.math.BigDecimal reimbursementsEndswith;
  /**
   * 赔偿收入 比较(isnull)
   */
  private Boolean reimbursementsIsnull;
  /**
   * 赔偿收入 比较(isnotnull)
   */
  private Boolean reimbursementsIsnotnull;

  /**
   * 追索收入
   */
  private java.math.BigDecimal clawbacks;

  /**
   * 最小追索收入
   */
  private java.math.BigDecimal clawbacksMin;

  /**
   * 最大追索收入
   */
  private java.math.BigDecimal clawbacksMax;

  /**
   * 追索收入 比较(eq)
   */
  private java.math.BigDecimal clawbacksEq;
  /**
   * 追索收入 比较(neq)
   */
  private java.math.BigDecimal clawbacksNeq;
  /**
   * 追索收入 比较(gt)
   */
  private java.math.BigDecimal clawbacksGt;
  /**
   * 追索收入 比较(gte)
   */
  private java.math.BigDecimal clawbacksGte;
  /**
   * 追索收入 比较(lt)
   */
  private java.math.BigDecimal clawbacksLt;
  /**
   * 追索收入 比较(lte)
   */
  private java.math.BigDecimal clawbacksLte;
  /**
   * 追索收入 比较(contains)
   */
  private java.math.BigDecimal clawbacksContains;
  /**
   * 追索收入 比较(notcontains)
   */
  private java.math.BigDecimal clawbacksNotcontains;
  /**
   * 追索收入 比较(startswith)
   */
  private java.math.BigDecimal clawbacksStartswith;
  /**
   * 追索收入 比较(endswith)
   */
  private java.math.BigDecimal clawbacksEndswith;
  /**
   * 追索收入 比较(isnull)
   */
  private Boolean clawbacksIsnull;
  /**
   * 追索收入 比较(isnotnull)
   */
  private Boolean clawbacksIsnotnull;

  /**
   * 混合VAT收入
   */
  private java.math.BigDecimal sharedComminglingVatIncome;

  /**
   * 最小混合VAT收入
   */
  private java.math.BigDecimal sharedComminglingVatIncomeMin;

  /**
   * 最大混合VAT收入
   */
  private java.math.BigDecimal sharedComminglingVatIncomeMax;

  /**
   * 混合VAT收入 比较(eq)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeEq;
  /**
   * 混合VAT收入 比较(neq)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeNeq;
  /**
   * 混合VAT收入 比较(gt)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeGt;
  /**
   * 混合VAT收入 比较(gte)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeGte;
  /**
   * 混合VAT收入 比较(lt)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeLt;
  /**
   * 混合VAT收入 比较(lte)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeLte;
  /**
   * 混合VAT收入 比较(contains)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeContains;
  /**
   * 混合VAT收入 比较(notcontains)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeNotcontains;
  /**
   * 混合VAT收入 比较(startswith)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeStartswith;
  /**
   * 混合VAT收入 比较(endswith)
   */
  private java.math.BigDecimal sharedComminglingVatIncomeEndswith;
  /**
   * 混合VAT收入 比较(isnull)
   */
  private Boolean sharedComminglingVatIncomeIsnull;
  /**
   * 混合VAT收入 比较(isnotnull)
   */
  private Boolean sharedComminglingVatIncomeIsnotnull;

  /**
   * 包装收入
   */
  private java.math.BigDecimal giftWrapCredits;

  /**
   * 最小包装收入
   */
  private java.math.BigDecimal giftWrapCreditsMin;

  /**
   * 最大包装收入
   */
  private java.math.BigDecimal giftWrapCreditsMax;

  /**
   * 包装收入 比较(eq)
   */
  private java.math.BigDecimal giftWrapCreditsEq;
  /**
   * 包装收入 比较(neq)
   */
  private java.math.BigDecimal giftWrapCreditsNeq;
  /**
   * 包装收入 比较(gt)
   */
  private java.math.BigDecimal giftWrapCreditsGt;
  /**
   * 包装收入 比较(gte)
   */
  private java.math.BigDecimal giftWrapCreditsGte;
  /**
   * 包装收入 比较(lt)
   */
  private java.math.BigDecimal giftWrapCreditsLt;
  /**
   * 包装收入 比较(lte)
   */
  private java.math.BigDecimal giftWrapCreditsLte;
  /**
   * 包装收入 比较(contains)
   */
  private java.math.BigDecimal giftWrapCreditsContains;
  /**
   * 包装收入 比较(notcontains)
   */
  private java.math.BigDecimal giftWrapCreditsNotcontains;
  /**
   * 包装收入 比较(startswith)
   */
  private java.math.BigDecimal giftWrapCreditsStartswith;
  /**
   * 包装收入 比较(endswith)
   */
  private java.math.BigDecimal giftWrapCreditsEndswith;
  /**
   * 包装收入 比较(isnull)
   */
  private Boolean giftWrapCreditsIsnull;
  /**
   * 包装收入 比较(isnotnull)
   */
  private Boolean giftWrapCreditsIsnotnull;

  /**
   * 买家交易保障索赔额
   */
  private java.math.BigDecimal guaranteeClaims;

  /**
   * 最小买家交易保障索赔额
   */
  private java.math.BigDecimal guaranteeClaimsMin;

  /**
   * 最大买家交易保障索赔额
   */
  private java.math.BigDecimal guaranteeClaimsMax;

  /**
   * 买家交易保障索赔额 比较(eq)
   */
  private java.math.BigDecimal guaranteeClaimsEq;
  /**
   * 买家交易保障索赔额 比较(neq)
   */
  private java.math.BigDecimal guaranteeClaimsNeq;
  /**
   * 买家交易保障索赔额 比较(gt)
   */
  private java.math.BigDecimal guaranteeClaimsGt;
  /**
   * 买家交易保障索赔额 比较(gte)
   */
  private java.math.BigDecimal guaranteeClaimsGte;
  /**
   * 买家交易保障索赔额 比较(lt)
   */
  private java.math.BigDecimal guaranteeClaimsLt;
  /**
   * 买家交易保障索赔额 比较(lte)
   */
  private java.math.BigDecimal guaranteeClaimsLte;
  /**
   * 买家交易保障索赔额 比较(contains)
   */
  private java.math.BigDecimal guaranteeClaimsContains;
  /**
   * 买家交易保障索赔额 比较(notcontains)
   */
  private java.math.BigDecimal guaranteeClaimsNotcontains;
  /**
   * 买家交易保障索赔额 比较(startswith)
   */
  private java.math.BigDecimal guaranteeClaimsStartswith;
  /**
   * 买家交易保障索赔额 比较(endswith)
   */
  private java.math.BigDecimal guaranteeClaimsEndswith;
  /**
   * 买家交易保障索赔额 比较(isnull)
   */
  private Boolean guaranteeClaimsIsnull;
  /**
   * 买家交易保障索赔额 比较(isnotnull)
   */
  private Boolean guaranteeClaimsIsnotnull;

  /**
   * 积分抵减收入
   */
  private java.math.BigDecimal costOfPoIntegersGranted;

  /**
   * 最小积分抵减收入
   */
  private java.math.BigDecimal costOfPoIntegersGrantedMin;

  /**
   * 最大积分抵减收入
   */
  private java.math.BigDecimal costOfPoIntegersGrantedMax;

  /**
   * 积分抵减收入 比较(eq)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedEq;
  /**
   * 积分抵减收入 比较(neq)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedNeq;
  /**
   * 积分抵减收入 比较(gt)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedGt;
  /**
   * 积分抵减收入 比较(gte)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedGte;
  /**
   * 积分抵减收入 比较(lt)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedLt;
  /**
   * 积分抵减收入 比较(lte)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedLte;
  /**
   * 积分抵减收入 比较(contains)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedContains;
  /**
   * 积分抵减收入 比较(notcontains)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedNotcontains;
  /**
   * 积分抵减收入 比较(startswith)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedStartswith;
  /**
   * 积分抵减收入 比较(endswith)
   */
  private java.math.BigDecimal costOfPoIntegersGrantedEndswith;
  /**
   * 积分抵减收入 比较(isnull)
   */
  private Boolean costOfPoIntegersGrantedIsnull;
  /**
   * 积分抵减收入 比较(isnotnull)
   */
  private Boolean costOfPoIntegersGrantedIsnotnull;

  /**
   * 收入退款额
   */
  private java.math.BigDecimal totalSalesRefunds;

  /**
   * 最小收入退款额
   */
  private java.math.BigDecimal totalSalesRefundsMin;

  /**
   * 最大收入退款额
   */
  private java.math.BigDecimal totalSalesRefundsMax;

  /**
   * 收入退款额 比较(eq)
   */
  private java.math.BigDecimal totalSalesRefundsEq;
  /**
   * 收入退款额 比较(neq)
   */
  private java.math.BigDecimal totalSalesRefundsNeq;
  /**
   * 收入退款额 比较(gt)
   */
  private java.math.BigDecimal totalSalesRefundsGt;
  /**
   * 收入退款额 比较(gte)
   */
  private java.math.BigDecimal totalSalesRefundsGte;
  /**
   * 收入退款额 比较(lt)
   */
  private java.math.BigDecimal totalSalesRefundsLt;
  /**
   * 收入退款额 比较(lte)
   */
  private java.math.BigDecimal totalSalesRefundsLte;
  /**
   * 收入退款额 比较(contains)
   */
  private java.math.BigDecimal totalSalesRefundsContains;
  /**
   * 收入退款额 比较(notcontains)
   */
  private java.math.BigDecimal totalSalesRefundsNotcontains;
  /**
   * 收入退款额 比较(startswith)
   */
  private java.math.BigDecimal totalSalesRefundsStartswith;
  /**
   * 收入退款额 比较(endswith)
   */
  private java.math.BigDecimal totalSalesRefundsEndswith;
  /**
   * 收入退款额 比较(isnull)
   */
  private Boolean totalSalesRefundsIsnull;
  /**
   * 收入退款额 比较(isnotnull)
   */
  private Boolean totalSalesRefundsIsnotnull;

  /**
   * FBA销售退款额
   */
  private java.math.BigDecimal fbaSalesRefunds;

  /**
   * 最小FBA销售退款额
   */
  private java.math.BigDecimal fbaSalesRefundsMin;

  /**
   * 最大FBA销售退款额
   */
  private java.math.BigDecimal fbaSalesRefundsMax;

  /**
   * FBA销售退款额 比较(eq)
   */
  private java.math.BigDecimal fbaSalesRefundsEq;
  /**
   * FBA销售退款额 比较(neq)
   */
  private java.math.BigDecimal fbaSalesRefundsNeq;
  /**
   * FBA销售退款额 比较(gt)
   */
  private java.math.BigDecimal fbaSalesRefundsGt;
  /**
   * FBA销售退款额 比较(gte)
   */
  private java.math.BigDecimal fbaSalesRefundsGte;
  /**
   * FBA销售退款额 比较(lt)
   */
  private java.math.BigDecimal fbaSalesRefundsLt;
  /**
   * FBA销售退款额 比较(lte)
   */
  private java.math.BigDecimal fbaSalesRefundsLte;
  /**
   * FBA销售退款额 比较(contains)
   */
  private java.math.BigDecimal fbaSalesRefundsContains;
  /**
   * FBA销售退款额 比较(notcontains)
   */
  private java.math.BigDecimal fbaSalesRefundsNotcontains;
  /**
   * FBA销售退款额 比较(startswith)
   */
  private java.math.BigDecimal fbaSalesRefundsStartswith;
  /**
   * FBA销售退款额 比较(endswith)
   */
  private java.math.BigDecimal fbaSalesRefundsEndswith;
  /**
   * FBA销售退款额 比较(isnull)
   */
  private Boolean fbaSalesRefundsIsnull;
  /**
   * FBA销售退款额 比较(isnotnull)
   */
  private Boolean fbaSalesRefundsIsnotnull;

  /**
   * FBM销售退款额
   */
  private java.math.BigDecimal fbmSalesRefunds;

  /**
   * 最小FBM销售退款额
   */
  private java.math.BigDecimal fbmSalesRefundsMin;

  /**
   * 最大FBM销售退款额
   */
  private java.math.BigDecimal fbmSalesRefundsMax;

  /**
   * FBM销售退款额 比较(eq)
   */
  private java.math.BigDecimal fbmSalesRefundsEq;
  /**
   * FBM销售退款额 比较(neq)
   */
  private java.math.BigDecimal fbmSalesRefundsNeq;
  /**
   * FBM销售退款额 比较(gt)
   */
  private java.math.BigDecimal fbmSalesRefundsGt;
  /**
   * FBM销售退款额 比较(gte)
   */
  private java.math.BigDecimal fbmSalesRefundsGte;
  /**
   * FBM销售退款额 比较(lt)
   */
  private java.math.BigDecimal fbmSalesRefundsLt;
  /**
   * FBM销售退款额 比较(lte)
   */
  private java.math.BigDecimal fbmSalesRefundsLte;
  /**
   * FBM销售退款额 比较(contains)
   */
  private java.math.BigDecimal fbmSalesRefundsContains;
  /**
   * FBM销售退款额 比较(notcontains)
   */
  private java.math.BigDecimal fbmSalesRefundsNotcontains;
  /**
   * FBM销售退款额 比较(startswith)
   */
  private java.math.BigDecimal fbmSalesRefundsStartswith;
  /**
   * FBM销售退款额 比较(endswith)
   */
  private java.math.BigDecimal fbmSalesRefundsEndswith;
  /**
   * FBM销售退款额 比较(isnull)
   */
  private Boolean fbmSalesRefundsIsnull;
  /**
   * FBM销售退款额 比较(isnotnull)
   */
  private Boolean fbmSalesRefundsIsnotnull;

  /**
   * 买家运费退款额
   */
  private java.math.BigDecimal shippingCreditRefunds;

  /**
   * 最小买家运费退款额
   */
  private java.math.BigDecimal shippingCreditRefundsMin;

  /**
   * 最大买家运费退款额
   */
  private java.math.BigDecimal shippingCreditRefundsMax;

  /**
   * 买家运费退款额 比较(eq)
   */
  private java.math.BigDecimal shippingCreditRefundsEq;
  /**
   * 买家运费退款额 比较(neq)
   */
  private java.math.BigDecimal shippingCreditRefundsNeq;
  /**
   * 买家运费退款额 比较(gt)
   */
  private java.math.BigDecimal shippingCreditRefundsGt;
  /**
   * 买家运费退款额 比较(gte)
   */
  private java.math.BigDecimal shippingCreditRefundsGte;
  /**
   * 买家运费退款额 比较(lt)
   */
  private java.math.BigDecimal shippingCreditRefundsLt;
  /**
   * 买家运费退款额 比较(lte)
   */
  private java.math.BigDecimal shippingCreditRefundsLte;
  /**
   * 买家运费退款额 比较(contains)
   */
  private java.math.BigDecimal shippingCreditRefundsContains;
  /**
   * 买家运费退款额 比较(notcontains)
   */
  private java.math.BigDecimal shippingCreditRefundsNotcontains;
  /**
   * 买家运费退款额 比较(startswith)
   */
  private java.math.BigDecimal shippingCreditRefundsStartswith;
  /**
   * 买家运费退款额 比较(endswith)
   */
  private java.math.BigDecimal shippingCreditRefundsEndswith;
  /**
   * 买家运费退款额 比较(isnull)
   */
  private Boolean shippingCreditRefundsIsnull;
  /**
   * 买家运费退款额 比较(isnotnull)
   */
  private Boolean shippingCreditRefundsIsnotnull;

  /**
   * 买家包装退款额
   */
  private java.math.BigDecimal giftWrapCreditRefunds;

  /**
   * 最小买家包装退款额
   */
  private java.math.BigDecimal giftWrapCreditRefundsMin;

  /**
   * 最大买家包装退款额
   */
  private java.math.BigDecimal giftWrapCreditRefundsMax;

  /**
   * 买家包装退款额 比较(eq)
   */
  private java.math.BigDecimal giftWrapCreditRefundsEq;
  /**
   * 买家包装退款额 比较(neq)
   */
  private java.math.BigDecimal giftWrapCreditRefundsNeq;
  /**
   * 买家包装退款额 比较(gt)
   */
  private java.math.BigDecimal giftWrapCreditRefundsGt;
  /**
   * 买家包装退款额 比较(gte)
   */
  private java.math.BigDecimal giftWrapCreditRefundsGte;
  /**
   * 买家包装退款额 比较(lt)
   */
  private java.math.BigDecimal giftWrapCreditRefundsLt;
  /**
   * 买家包装退款额 比较(lte)
   */
  private java.math.BigDecimal giftWrapCreditRefundsLte;
  /**
   * 买家包装退款额 比较(contains)
   */
  private java.math.BigDecimal giftWrapCreditRefundsContains;
  /**
   * 买家包装退款额 比较(notcontains)
   */
  private java.math.BigDecimal giftWrapCreditRefundsNotcontains;
  /**
   * 买家包装退款额 比较(startswith)
   */
  private java.math.BigDecimal giftWrapCreditRefundsStartswith;
  /**
   * 买家包装退款额 比较(endswith)
   */
  private java.math.BigDecimal giftWrapCreditRefundsEndswith;
  /**
   * 买家包装退款额 比较(isnull)
   */
  private Boolean giftWrapCreditRefundsIsnull;
  /**
   * 买家包装退款额 比较(isnotnull)
   */
  private Boolean giftWrapCreditRefundsIsnotnull;

  /**
   * 卖家拒付
   */
  private java.math.BigDecimal chargebacks;

  /**
   * 最小卖家拒付
   */
  private java.math.BigDecimal chargebacksMin;

  /**
   * 最大卖家拒付
   */
  private java.math.BigDecimal chargebacksMax;

  /**
   * 卖家拒付 比较(eq)
   */
  private java.math.BigDecimal chargebacksEq;
  /**
   * 卖家拒付 比较(neq)
   */
  private java.math.BigDecimal chargebacksNeq;
  /**
   * 卖家拒付 比较(gt)
   */
  private java.math.BigDecimal chargebacksGt;
  /**
   * 卖家拒付 比较(gte)
   */
  private java.math.BigDecimal chargebacksGte;
  /**
   * 卖家拒付 比较(lt)
   */
  private java.math.BigDecimal chargebacksLt;
  /**
   * 卖家拒付 比较(lte)
   */
  private java.math.BigDecimal chargebacksLte;
  /**
   * 卖家拒付 比较(contains)
   */
  private java.math.BigDecimal chargebacksContains;
  /**
   * 卖家拒付 比较(notcontains)
   */
  private java.math.BigDecimal chargebacksNotcontains;
  /**
   * 卖家拒付 比较(startswith)
   */
  private java.math.BigDecimal chargebacksStartswith;
  /**
   * 卖家拒付 比较(endswith)
   */
  private java.math.BigDecimal chargebacksEndswith;
  /**
   * 卖家拒付 比较(isnull)
   */
  private Boolean chargebacksIsnull;
  /**
   * 卖家拒付 比较(isnotnull)
   */
  private Boolean chargebacksIsnotnull;

  /**
   * 积分抵减退回
   */
  private java.math.BigDecimal costOfPoIntegersReturned;

  /**
   * 最小积分抵减退回
   */
  private java.math.BigDecimal costOfPoIntegersReturnedMin;

  /**
   * 最大积分抵减退回
   */
  private java.math.BigDecimal costOfPoIntegersReturnedMax;

  /**
   * 积分抵减退回 比较(eq)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedEq;
  /**
   * 积分抵减退回 比较(neq)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedNeq;
  /**
   * 积分抵减退回 比较(gt)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedGt;
  /**
   * 积分抵减退回 比较(gte)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedGte;
  /**
   * 积分抵减退回 比较(lt)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedLt;
  /**
   * 积分抵减退回 比较(lte)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedLte;
  /**
   * 积分抵减退回 比较(contains)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedContains;
  /**
   * 积分抵减退回 比较(notcontains)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedNotcontains;
  /**
   * 积分抵减退回 比较(startswith)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedStartswith;
  /**
   * 积分抵减退回 比较(endswith)
   */
  private java.math.BigDecimal costOfPoIntegersReturnedEndswith;
  /**
   * 积分抵减退回 比较(isnull)
   */
  private Boolean costOfPoIntegersReturnedIsnull;
  /**
   * 积分抵减退回 比较(isnotnull)
   */
  private Boolean costOfPoIntegersReturnedIsnotnull;

  /**
   * 促销折扣退款额
   */
  private java.math.BigDecimal promotionalRebateRefunds;

  /**
   * 最小促销折扣退款额
   */
  private java.math.BigDecimal promotionalRebateRefundsMin;

  /**
   * 最大促销折扣退款额
   */
  private java.math.BigDecimal promotionalRebateRefundsMax;

  /**
   * 促销折扣退款额 比较(eq)
   */
  private java.math.BigDecimal promotionalRebateRefundsEq;
  /**
   * 促销折扣退款额 比较(neq)
   */
  private java.math.BigDecimal promotionalRebateRefundsNeq;
  /**
   * 促销折扣退款额 比较(gt)
   */
  private java.math.BigDecimal promotionalRebateRefundsGt;
  /**
   * 促销折扣退款额 比较(gte)
   */
  private java.math.BigDecimal promotionalRebateRefundsGte;
  /**
   * 促销折扣退款额 比较(lt)
   */
  private java.math.BigDecimal promotionalRebateRefundsLt;
  /**
   * 促销折扣退款额 比较(lte)
   */
  private java.math.BigDecimal promotionalRebateRefundsLte;
  /**
   * 促销折扣退款额 比较(contains)
   */
  private java.math.BigDecimal promotionalRebateRefundsContains;
  /**
   * 促销折扣退款额 比较(notcontains)
   */
  private java.math.BigDecimal promotionalRebateRefundsNotcontains;
  /**
   * 促销折扣退款额 比较(startswith)
   */
  private java.math.BigDecimal promotionalRebateRefundsStartswith;
  /**
   * 促销折扣退款额 比较(endswith)
   */
  private java.math.BigDecimal promotionalRebateRefundsEndswith;
  /**
   * 促销折扣退款额 比较(isnull)
   */
  private Boolean promotionalRebateRefundsIsnull;
  /**
   * 促销折扣退款额 比较(isnotnull)
   */
  private Boolean promotionalRebateRefundsIsnotnull;

  /**
   * 费用退款额
   */
  private java.math.BigDecimal totalFeeRefunds;

  /**
   * 最小费用退款额
   */
  private java.math.BigDecimal totalFeeRefundsMin;

  /**
   * 最大费用退款额
   */
  private java.math.BigDecimal totalFeeRefundsMax;

  /**
   * 费用退款额 比较(eq)
   */
  private java.math.BigDecimal totalFeeRefundsEq;
  /**
   * 费用退款额 比较(neq)
   */
  private java.math.BigDecimal totalFeeRefundsNeq;
  /**
   * 费用退款额 比较(gt)
   */
  private java.math.BigDecimal totalFeeRefundsGt;
  /**
   * 费用退款额 比较(gte)
   */
  private java.math.BigDecimal totalFeeRefundsGte;
  /**
   * 费用退款额 比较(lt)
   */
  private java.math.BigDecimal totalFeeRefundsLt;
  /**
   * 费用退款额 比较(lte)
   */
  private java.math.BigDecimal totalFeeRefundsLte;
  /**
   * 费用退款额 比较(contains)
   */
  private java.math.BigDecimal totalFeeRefundsContains;
  /**
   * 费用退款额 比较(notcontains)
   */
  private java.math.BigDecimal totalFeeRefundsNotcontains;
  /**
   * 费用退款额 比较(startswith)
   */
  private java.math.BigDecimal totalFeeRefundsStartswith;
  /**
   * 费用退款额 比较(endswith)
   */
  private java.math.BigDecimal totalFeeRefundsEndswith;
  /**
   * 费用退款额 比较(isnull)
   */
  private Boolean totalFeeRefundsIsnull;
  /**
   * 费用退款额 比较(isnotnull)
   */
  private Boolean totalFeeRefundsIsnotnull;

  /**
   * 平台费退款额
   */
  private java.math.BigDecimal sellingFeeRefunds;

  /**
   * 最小平台费退款额
   */
  private java.math.BigDecimal sellingFeeRefundsMin;

  /**
   * 最大平台费退款额
   */
  private java.math.BigDecimal sellingFeeRefundsMax;

  /**
   * 平台费退款额 比较(eq)
   */
  private java.math.BigDecimal sellingFeeRefundsEq;
  /**
   * 平台费退款额 比较(neq)
   */
  private java.math.BigDecimal sellingFeeRefundsNeq;
  /**
   * 平台费退款额 比较(gt)
   */
  private java.math.BigDecimal sellingFeeRefundsGt;
  /**
   * 平台费退款额 比较(gte)
   */
  private java.math.BigDecimal sellingFeeRefundsGte;
  /**
   * 平台费退款额 比较(lt)
   */
  private java.math.BigDecimal sellingFeeRefundsLt;
  /**
   * 平台费退款额 比较(lte)
   */
  private java.math.BigDecimal sellingFeeRefundsLte;
  /**
   * 平台费退款额 比较(contains)
   */
  private java.math.BigDecimal sellingFeeRefundsContains;
  /**
   * 平台费退款额 比较(notcontains)
   */
  private java.math.BigDecimal sellingFeeRefundsNotcontains;
  /**
   * 平台费退款额 比较(startswith)
   */
  private java.math.BigDecimal sellingFeeRefundsStartswith;
  /**
   * 平台费退款额 比较(endswith)
   */
  private java.math.BigDecimal sellingFeeRefundsEndswith;
  /**
   * 平台费退款额 比较(isnull)
   */
  private Boolean sellingFeeRefundsIsnull;
  /**
   * 平台费退款额 比较(isnotnull)
   */
  private Boolean sellingFeeRefundsIsnotnull;

  /**
   * 发货费退款额
   */
  private java.math.BigDecimal fbaTransactionFeeRefunds;

  /**
   * 最小发货费退款额
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsMin;

  /**
   * 最大发货费退款额
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsMax;

  /**
   * 发货费退款额 比较(eq)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsEq;
  /**
   * 发货费退款额 比较(neq)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsNeq;
  /**
   * 发货费退款额 比较(gt)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsGt;
  /**
   * 发货费退款额 比较(gte)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsGte;
  /**
   * 发货费退款额 比较(lt)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsLt;
  /**
   * 发货费退款额 比较(lte)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsLte;
  /**
   * 发货费退款额 比较(contains)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsContains;
  /**
   * 发货费退款额 比较(notcontains)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsNotcontains;
  /**
   * 发货费退款额 比较(startswith)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsStartswith;
  /**
   * 发货费退款额 比较(endswith)
   */
  private java.math.BigDecimal fbaTransactionFeeRefundsEndswith;
  /**
   * 发货费退款额 比较(isnull)
   */
  private Boolean fbaTransactionFeeRefundsIsnull;
  /**
   * 发货费退款额 比较(isnotnull)
   */
  private Boolean fbaTransactionFeeRefundsIsnotnull;

  /**
   * 交易费用退款额
   */
  private java.math.BigDecimal refundAdministrationFees;

  /**
   * 最小交易费用退款额
   */
  private java.math.BigDecimal refundAdministrationFeesMin;

  /**
   * 最大交易费用退款额
   */
  private java.math.BigDecimal refundAdministrationFeesMax;

  /**
   * 交易费用退款额 比较(eq)
   */
  private java.math.BigDecimal refundAdministrationFeesEq;
  /**
   * 交易费用退款额 比较(neq)
   */
  private java.math.BigDecimal refundAdministrationFeesNeq;
  /**
   * 交易费用退款额 比较(gt)
   */
  private java.math.BigDecimal refundAdministrationFeesGt;
  /**
   * 交易费用退款额 比较(gte)
   */
  private java.math.BigDecimal refundAdministrationFeesGte;
  /**
   * 交易费用退款额 比较(lt)
   */
  private java.math.BigDecimal refundAdministrationFeesLt;
  /**
   * 交易费用退款额 比较(lte)
   */
  private java.math.BigDecimal refundAdministrationFeesLte;
  /**
   * 交易费用退款额 比较(contains)
   */
  private java.math.BigDecimal refundAdministrationFeesContains;
  /**
   * 交易费用退款额 比较(notcontains)
   */
  private java.math.BigDecimal refundAdministrationFeesNotcontains;
  /**
   * 交易费用退款额 比较(startswith)
   */
  private java.math.BigDecimal refundAdministrationFeesStartswith;
  /**
   * 交易费用退款额 比较(endswith)
   */
  private java.math.BigDecimal refundAdministrationFeesEndswith;
  /**
   * 交易费用退款额 比较(isnull)
   */
  private Boolean refundAdministrationFeesIsnull;
  /**
   * 交易费用退款额 比较(isnotnull)
   */
  private Boolean refundAdministrationFeesIsnotnull;

  /**
   * 其他订单费退款额
   */
  private java.math.BigDecimal otherTransactionFeeRefunds;

  /**
   * 最小其他订单费退款额
   */
  private java.math.BigDecimal otherTransactionFeeRefundsMin;

  /**
   * 最大其他订单费退款额
   */
  private java.math.BigDecimal otherTransactionFeeRefundsMax;

  /**
   * 其他订单费退款额 比较(eq)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsEq;
  /**
   * 其他订单费退款额 比较(neq)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsNeq;
  /**
   * 其他订单费退款额 比较(gt)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsGt;
  /**
   * 其他订单费退款额 比较(gte)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsGte;
  /**
   * 其他订单费退款额 比较(lt)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsLt;
  /**
   * 其他订单费退款额 比较(lte)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsLte;
  /**
   * 其他订单费退款额 比较(contains)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsContains;
  /**
   * 其他订单费退款额 比较(notcontains)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsNotcontains;
  /**
   * 其他订单费退款额 比较(startswith)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsStartswith;
  /**
   * 其他订单费退款额 比较(endswith)
   */
  private java.math.BigDecimal otherTransactionFeeRefundsEndswith;
  /**
   * 其他订单费退款额 比较(isnull)
   */
  private Boolean otherTransactionFeeRefundsIsnull;
  /**
   * 其他订单费退款额 比较(isnotnull)
   */
  private Boolean otherTransactionFeeRefundsIsnotnull;

  /**
   * 广告退款额
   */
  private java.math.BigDecimal refundForAdvertiser;

  /**
   * 最小广告退款额
   */
  private java.math.BigDecimal refundForAdvertiserMin;

  /**
   * 最大广告退款额
   */
  private java.math.BigDecimal refundForAdvertiserMax;

  /**
   * 广告退款额 比较(eq)
   */
  private java.math.BigDecimal refundForAdvertiserEq;
  /**
   * 广告退款额 比较(neq)
   */
  private java.math.BigDecimal refundForAdvertiserNeq;
  /**
   * 广告退款额 比较(gt)
   */
  private java.math.BigDecimal refundForAdvertiserGt;
  /**
   * 广告退款额 比较(gte)
   */
  private java.math.BigDecimal refundForAdvertiserGte;
  /**
   * 广告退款额 比较(lt)
   */
  private java.math.BigDecimal refundForAdvertiserLt;
  /**
   * 广告退款额 比较(lte)
   */
  private java.math.BigDecimal refundForAdvertiserLte;
  /**
   * 广告退款额 比较(contains)
   */
  private java.math.BigDecimal refundForAdvertiserContains;
  /**
   * 广告退款额 比较(notcontains)
   */
  private java.math.BigDecimal refundForAdvertiserNotcontains;
  /**
   * 广告退款额 比较(startswith)
   */
  private java.math.BigDecimal refundForAdvertiserStartswith;
  /**
   * 广告退款额 比较(endswith)
   */
  private java.math.BigDecimal refundForAdvertiserEndswith;
  /**
   * 广告退款额 比较(isnull)
   */
  private Boolean refundForAdvertiserIsnull;
  /**
   * 广告退款额 比较(isnotnull)
   */
  private Boolean refundForAdvertiserIsnotnull;

  /**
   * 积分费用
   */
  private java.math.BigDecimal pointsAdjusted;

  /**
   * 最小积分费用
   */
  private java.math.BigDecimal pointsAdjustedMin;

  /**
   * 最大积分费用
   */
  private java.math.BigDecimal pointsAdjustedMax;

  /**
   * 积分费用 比较(eq)
   */
  private java.math.BigDecimal pointsAdjustedEq;
  /**
   * 积分费用 比较(neq)
   */
  private java.math.BigDecimal pointsAdjustedNeq;
  /**
   * 积分费用 比较(gt)
   */
  private java.math.BigDecimal pointsAdjustedGt;
  /**
   * 积分费用 比较(gte)
   */
  private java.math.BigDecimal pointsAdjustedGte;
  /**
   * 积分费用 比较(lt)
   */
  private java.math.BigDecimal pointsAdjustedLt;
  /**
   * 积分费用 比较(lte)
   */
  private java.math.BigDecimal pointsAdjustedLte;
  /**
   * 积分费用 比较(contains)
   */
  private java.math.BigDecimal pointsAdjustedContains;
  /**
   * 积分费用 比较(notcontains)
   */
  private java.math.BigDecimal pointsAdjustedNotcontains;
  /**
   * 积分费用 比较(startswith)
   */
  private java.math.BigDecimal pointsAdjustedStartswith;
  /**
   * 积分费用 比较(endswith)
   */
  private java.math.BigDecimal pointsAdjustedEndswith;
  /**
   * 积分费用 比较(isnull)
   */
  private Boolean pointsAdjustedIsnull;
  /**
   * 积分费用 比较(isnotnull)
   */
  private Boolean pointsAdjustedIsnotnull;

  /**
   * 运输标签费退款
   */
  private java.math.BigDecimal shippingLabelRefunds;

  /**
   * 最小运输标签费退款
   */
  private java.math.BigDecimal shippingLabelRefundsMin;

  /**
   * 最大运输标签费退款
   */
  private java.math.BigDecimal shippingLabelRefundsMax;

  /**
   * 运输标签费退款 比较(eq)
   */
  private java.math.BigDecimal shippingLabelRefundsEq;
  /**
   * 运输标签费退款 比较(neq)
   */
  private java.math.BigDecimal shippingLabelRefundsNeq;
  /**
   * 运输标签费退款 比较(gt)
   */
  private java.math.BigDecimal shippingLabelRefundsGt;
  /**
   * 运输标签费退款 比较(gte)
   */
  private java.math.BigDecimal shippingLabelRefundsGte;
  /**
   * 运输标签费退款 比较(lt)
   */
  private java.math.BigDecimal shippingLabelRefundsLt;
  /**
   * 运输标签费退款 比较(lte)
   */
  private java.math.BigDecimal shippingLabelRefundsLte;
  /**
   * 运输标签费退款 比较(contains)
   */
  private java.math.BigDecimal shippingLabelRefundsContains;
  /**
   * 运输标签费退款 比较(notcontains)
   */
  private java.math.BigDecimal shippingLabelRefundsNotcontains;
  /**
   * 运输标签费退款 比较(startswith)
   */
  private java.math.BigDecimal shippingLabelRefundsStartswith;
  /**
   * 运输标签费退款 比较(endswith)
   */
  private java.math.BigDecimal shippingLabelRefundsEndswith;
  /**
   * 运输标签费退款 比较(isnull)
   */
  private Boolean shippingLabelRefundsIsnull;
  /**
   * 运输标签费退款 比较(isnotnull)
   */
  private Boolean shippingLabelRefundsIsnotnull;

  /**
   * 退款量
   */
  private Integer refundsQuantity;

  /**
   * 最小退款量
   */
  private Integer refundsQuantityMin;

  /**
   * 最大退款量
   */
  private Integer refundsQuantityMax;

  /**
   * 退款量 比较(eq)
   */
  private Integer refundsQuantityEq;
  /**
   * 退款量 比较(neq)
   */
  private Integer refundsQuantityNeq;
  /**
   * 退款量 比较(gt)
   */
  private Integer refundsQuantityGt;
  /**
   * 退款量 比较(gte)
   */
  private Integer refundsQuantityGte;
  /**
   * 退款量 比较(lt)
   */
  private Integer refundsQuantityLt;
  /**
   * 退款量 比较(lte)
   */
  private Integer refundsQuantityLte;
  /**
   * 退款量 比较(contains)
   */
  private Integer refundsQuantityContains;
  /**
   * 退款量 比较(notcontains)
   */
  private Integer refundsQuantityNotcontains;
  /**
   * 退款量 比较(startswith)
   */
  private Integer refundsQuantityStartswith;
  /**
   * 退款量 比较(endswith)
   */
  private Integer refundsQuantityEndswith;
  /**
   * 退款量 比较(isnull)
   */
  private Boolean refundsQuantityIsnull;
  /**
   * 退款量 比较(isnotnull)
   */
  private Boolean refundsQuantityIsnotnull;

  /**
   * 退款率
   */
  private java.math.BigDecimal refundsRate;

  /**
   * 最小退款率
   */
  private java.math.BigDecimal refundsRateMin;

  /**
   * 最大退款率
   */
  private java.math.BigDecimal refundsRateMax;

  /**
   * 退款率 比较(eq)
   */
  private java.math.BigDecimal refundsRateEq;
  /**
   * 退款率 比较(neq)
   */
  private java.math.BigDecimal refundsRateNeq;
  /**
   * 退款率 比较(gt)
   */
  private java.math.BigDecimal refundsRateGt;
  /**
   * 退款率 比较(gte)
   */
  private java.math.BigDecimal refundsRateGte;
  /**
   * 退款率 比较(lt)
   */
  private java.math.BigDecimal refundsRateLt;
  /**
   * 退款率 比较(lte)
   */
  private java.math.BigDecimal refundsRateLte;
  /**
   * 退款率 比较(contains)
   */
  private java.math.BigDecimal refundsRateContains;
  /**
   * 退款率 比较(notcontains)
   */
  private java.math.BigDecimal refundsRateNotcontains;
  /**
   * 退款率 比较(startswith)
   */
  private java.math.BigDecimal refundsRateStartswith;
  /**
   * 退款率 比较(endswith)
   */
  private java.math.BigDecimal refundsRateEndswith;
  /**
   * 退款率 比较(isnull)
   */
  private Boolean refundsRateIsnull;
  /**
   * 退款率 比较(isnotnull)
   */
  private Boolean refundsRateIsnotnull;

  /**
   * 退货量
   */
  private Integer fbaReturnsQuantity;

  /**
   * 最小退货量
   */
  private Integer fbaReturnsQuantityMin;

  /**
   * 最大退货量
   */
  private Integer fbaReturnsQuantityMax;

  /**
   * 退货量 比较(eq)
   */
  private Integer fbaReturnsQuantityEq;
  /**
   * 退货量 比较(neq)
   */
  private Integer fbaReturnsQuantityNeq;
  /**
   * 退货量 比较(gt)
   */
  private Integer fbaReturnsQuantityGt;
  /**
   * 退货量 比较(gte)
   */
  private Integer fbaReturnsQuantityGte;
  /**
   * 退货量 比较(lt)
   */
  private Integer fbaReturnsQuantityLt;
  /**
   * 退货量 比较(lte)
   */
  private Integer fbaReturnsQuantityLte;
  /**
   * 退货量 比较(contains)
   */
  private Integer fbaReturnsQuantityContains;
  /**
   * 退货量 比较(notcontains)
   */
  private Integer fbaReturnsQuantityNotcontains;
  /**
   * 退货量 比较(startswith)
   */
  private Integer fbaReturnsQuantityStartswith;
  /**
   * 退货量 比较(endswith)
   */
  private Integer fbaReturnsQuantityEndswith;
  /**
   * 退货量 比较(isnull)
   */
  private Boolean fbaReturnsQuantityIsnull;
  /**
   * 退货量 比较(isnotnull)
   */
  private Boolean fbaReturnsQuantityIsnotnull;

  /**
   * 退货量（可售）
   */
  private Integer fbaReturnsSaleableQuantity;

  /**
   * 最小退货量（可售）
   */
  private Integer fbaReturnsSaleableQuantityMin;

  /**
   * 最大退货量（可售）
   */
  private Integer fbaReturnsSaleableQuantityMax;

  /**
   * 退货量（可售） 比较(eq)
   */
  private Integer fbaReturnsSaleableQuantityEq;
  /**
   * 退货量（可售） 比较(neq)
   */
  private Integer fbaReturnsSaleableQuantityNeq;
  /**
   * 退货量（可售） 比较(gt)
   */
  private Integer fbaReturnsSaleableQuantityGt;
  /**
   * 退货量（可售） 比较(gte)
   */
  private Integer fbaReturnsSaleableQuantityGte;
  /**
   * 退货量（可售） 比较(lt)
   */
  private Integer fbaReturnsSaleableQuantityLt;
  /**
   * 退货量（可售） 比较(lte)
   */
  private Integer fbaReturnsSaleableQuantityLte;
  /**
   * 退货量（可售） 比较(contains)
   */
  private Integer fbaReturnsSaleableQuantityContains;
  /**
   * 退货量（可售） 比较(notcontains)
   */
  private Integer fbaReturnsSaleableQuantityNotcontains;
  /**
   * 退货量（可售） 比较(startswith)
   */
  private Integer fbaReturnsSaleableQuantityStartswith;
  /**
   * 退货量（可售） 比较(endswith)
   */
  private Integer fbaReturnsSaleableQuantityEndswith;
  /**
   * 退货量（可售） 比较(isnull)
   */
  private Boolean fbaReturnsSaleableQuantityIsnull;
  /**
   * 退货量（可售） 比较(isnotnull)
   */
  private Boolean fbaReturnsSaleableQuantityIsnotnull;

  /**
   * 退货量（不可售）
   */
  private Integer fbaReturnsUnsaleableQuantity;

  /**
   * 最小退货量（不可售）
   */
  private Integer fbaReturnsUnsaleableQuantityMin;

  /**
   * 最大退货量（不可售）
   */
  private Integer fbaReturnsUnsaleableQuantityMax;

  /**
   * 退货量（不可售） 比较(eq)
   */
  private Integer fbaReturnsUnsaleableQuantityEq;
  /**
   * 退货量（不可售） 比较(neq)
   */
  private Integer fbaReturnsUnsaleableQuantityNeq;
  /**
   * 退货量（不可售） 比较(gt)
   */
  private Integer fbaReturnsUnsaleableQuantityGt;
  /**
   * 退货量（不可售） 比较(gte)
   */
  private Integer fbaReturnsUnsaleableQuantityGte;
  /**
   * 退货量（不可售） 比较(lt)
   */
  private Integer fbaReturnsUnsaleableQuantityLt;
  /**
   * 退货量（不可售） 比较(lte)
   */
  private Integer fbaReturnsUnsaleableQuantityLte;
  /**
   * 退货量（不可售） 比较(contains)
   */
  private Integer fbaReturnsUnsaleableQuantityContains;
  /**
   * 退货量（不可售） 比较(notcontains)
   */
  private Integer fbaReturnsUnsaleableQuantityNotcontains;
  /**
   * 退货量（不可售） 比较(startswith)
   */
  private Integer fbaReturnsUnsaleableQuantityStartswith;
  /**
   * 退货量（不可售） 比较(endswith)
   */
  private Integer fbaReturnsUnsaleableQuantityEndswith;
  /**
   * 退货量（不可售） 比较(isnull)
   */
  private Boolean fbaReturnsUnsaleableQuantityIsnull;
  /**
   * 退货量（不可售） 比较(isnotnull)
   */
  private Boolean fbaReturnsUnsaleableQuantityIsnotnull;

  /**
   * 退货率
   */
  private java.math.BigDecimal fbaReturnsQuantityRate;

  /**
   * 最小退货率
   */
  private java.math.BigDecimal fbaReturnsQuantityRateMin;

  /**
   * 最大退货率
   */
  private java.math.BigDecimal fbaReturnsQuantityRateMax;

  /**
   * 退货率 比较(eq)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateEq;
  /**
   * 退货率 比较(neq)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateNeq;
  /**
   * 退货率 比较(gt)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateGt;
  /**
   * 退货率 比较(gte)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateGte;
  /**
   * 退货率 比较(lt)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateLt;
  /**
   * 退货率 比较(lte)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateLte;
  /**
   * 退货率 比较(contains)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateContains;
  /**
   * 退货率 比较(notcontains)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateNotcontains;
  /**
   * 退货率 比较(startswith)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateStartswith;
  /**
   * 退货率 比较(endswith)
   */
  private java.math.BigDecimal fbaReturnsQuantityRateEndswith;
  /**
   * 退货率 比较(isnull)
   */
  private Boolean fbaReturnsQuantityRateIsnull;
  /**
   * 退货率 比较(isnotnull)
   */
  private Boolean fbaReturnsQuantityRateIsnotnull;

  /**
   * 平台费
   */
  private java.math.BigDecimal platformFee;

  /**
   * 最小平台费
   */
  private java.math.BigDecimal platformFeeMin;

  /**
   * 最大平台费
   */
  private java.math.BigDecimal platformFeeMax;

  /**
   * 平台费 比较(eq)
   */
  private java.math.BigDecimal platformFeeEq;
  /**
   * 平台费 比较(neq)
   */
  private java.math.BigDecimal platformFeeNeq;
  /**
   * 平台费 比较(gt)
   */
  private java.math.BigDecimal platformFeeGt;
  /**
   * 平台费 比较(gte)
   */
  private java.math.BigDecimal platformFeeGte;
  /**
   * 平台费 比较(lt)
   */
  private java.math.BigDecimal platformFeeLt;
  /**
   * 平台费 比较(lte)
   */
  private java.math.BigDecimal platformFeeLte;
  /**
   * 平台费 比较(contains)
   */
  private java.math.BigDecimal platformFeeContains;
  /**
   * 平台费 比较(notcontains)
   */
  private java.math.BigDecimal platformFeeNotcontains;
  /**
   * 平台费 比较(startswith)
   */
  private java.math.BigDecimal platformFeeStartswith;
  /**
   * 平台费 比较(endswith)
   */
  private java.math.BigDecimal platformFeeEndswith;
  /**
   * 平台费 比较(isnull)
   */
  private Boolean platformFeeIsnull;
  /**
   * 平台费 比较(isnotnull)
   */
  private Boolean platformFeeIsnotnull;

  /**
   * FBA发货费
   */
  private java.math.BigDecimal fbaDeliveryFee;

  /**
   * 最小FBA发货费
   */
  private java.math.BigDecimal fbaDeliveryFeeMin;

  /**
   * 最大FBA发货费
   */
  private java.math.BigDecimal fbaDeliveryFeeMax;

  /**
   * FBA发货费 比较(eq)
   */
  private java.math.BigDecimal fbaDeliveryFeeEq;
  /**
   * FBA发货费 比较(neq)
   */
  private java.math.BigDecimal fbaDeliveryFeeNeq;
  /**
   * FBA发货费 比较(gt)
   */
  private java.math.BigDecimal fbaDeliveryFeeGt;
  /**
   * FBA发货费 比较(gte)
   */
  private java.math.BigDecimal fbaDeliveryFeeGte;
  /**
   * FBA发货费 比较(lt)
   */
  private java.math.BigDecimal fbaDeliveryFeeLt;
  /**
   * FBA发货费 比较(lte)
   */
  private java.math.BigDecimal fbaDeliveryFeeLte;
  /**
   * FBA发货费 比较(contains)
   */
  private java.math.BigDecimal fbaDeliveryFeeContains;
  /**
   * FBA发货费 比较(notcontains)
   */
  private java.math.BigDecimal fbaDeliveryFeeNotcontains;
  /**
   * FBA发货费 比较(startswith)
   */
  private java.math.BigDecimal fbaDeliveryFeeStartswith;
  /**
   * FBA发货费 比较(endswith)
   */
  private java.math.BigDecimal fbaDeliveryFeeEndswith;
  /**
   * FBA发货费 比较(isnull)
   */
  private Boolean fbaDeliveryFeeIsnull;
  /**
   * FBA发货费 比较(isnotnull)
   */
  private Boolean fbaDeliveryFeeIsnotnull;

  /**
   * FBA发货费(多渠道)
   */
  private java.math.BigDecimal mcFbaDeliveryFee;

  /**
   * 最小FBA发货费(多渠道)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeMin;

  /**
   * 最大FBA发货费(多渠道)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeMax;

  /**
   * FBA发货费(多渠道) 比较(eq)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeEq;
  /**
   * FBA发货费(多渠道) 比较(neq)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeNeq;
  /**
   * FBA发货费(多渠道) 比较(gt)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeGt;
  /**
   * FBA发货费(多渠道) 比较(gte)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeGte;
  /**
   * FBA发货费(多渠道) 比较(lt)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeLt;
  /**
   * FBA发货费(多渠道) 比较(lte)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeLte;
  /**
   * FBA发货费(多渠道) 比较(contains)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeContains;
  /**
   * FBA发货费(多渠道) 比较(notcontains)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeNotcontains;
  /**
   * FBA发货费(多渠道) 比较(startswith)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeStartswith;
  /**
   * FBA发货费(多渠道) 比较(endswith)
   */
  private java.math.BigDecimal mcFbaDeliveryFeeEndswith;
  /**
   * FBA发货费(多渠道) 比较(isnull)
   */
  private Boolean mcFbaDeliveryFeeIsnull;
  /**
   * FBA发货费(多渠道) 比较(isnotnull)
   */
  private Boolean mcFbaDeliveryFeeIsnotnull;

  /**
   * FBA发货费合计
   */
  private java.math.BigDecimal totalFbaDeliveryFee;

  /**
   * 最小FBA发货费合计
   */
  private java.math.BigDecimal totalFbaDeliveryFeeMin;

  /**
   * 最大FBA发货费合计
   */
  private java.math.BigDecimal totalFbaDeliveryFeeMax;

  /**
   * FBA发货费合计 比较(eq)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeEq;
  /**
   * FBA发货费合计 比较(neq)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeNeq;
  /**
   * FBA发货费合计 比较(gt)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeGt;
  /**
   * FBA发货费合计 比较(gte)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeGte;
  /**
   * FBA发货费合计 比较(lt)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeLt;
  /**
   * FBA发货费合计 比较(lte)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeLte;
  /**
   * FBA发货费合计 比较(contains)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeContains;
  /**
   * FBA发货费合计 比较(notcontains)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeNotcontains;
  /**
   * FBA发货费合计 比较(startswith)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeStartswith;
  /**
   * FBA发货费合计 比较(endswith)
   */
  private java.math.BigDecimal totalFbaDeliveryFeeEndswith;
  /**
   * FBA发货费合计 比较(isnull)
   */
  private Boolean totalFbaDeliveryFeeIsnull;
  /**
   * FBA发货费合计 比较(isnotnull)
   */
  private Boolean totalFbaDeliveryFeeIsnotnull;

  /**
   * 其他订单费用
   */
  private java.math.BigDecimal otherTransactionFees;

  /**
   * 最小其他订单费用
   */
  private java.math.BigDecimal otherTransactionFeesMin;

  /**
   * 最大其他订单费用
   */
  private java.math.BigDecimal otherTransactionFeesMax;

  /**
   * 其他订单费用 比较(eq)
   */
  private java.math.BigDecimal otherTransactionFeesEq;
  /**
   * 其他订单费用 比较(neq)
   */
  private java.math.BigDecimal otherTransactionFeesNeq;
  /**
   * 其他订单费用 比较(gt)
   */
  private java.math.BigDecimal otherTransactionFeesGt;
  /**
   * 其他订单费用 比较(gte)
   */
  private java.math.BigDecimal otherTransactionFeesGte;
  /**
   * 其他订单费用 比较(lt)
   */
  private java.math.BigDecimal otherTransactionFeesLt;
  /**
   * 其他订单费用 比较(lte)
   */
  private java.math.BigDecimal otherTransactionFeesLte;
  /**
   * 其他订单费用 比较(contains)
   */
  private java.math.BigDecimal otherTransactionFeesContains;
  /**
   * 其他订单费用 比较(notcontains)
   */
  private java.math.BigDecimal otherTransactionFeesNotcontains;
  /**
   * 其他订单费用 比较(startswith)
   */
  private java.math.BigDecimal otherTransactionFeesStartswith;
  /**
   * 其他订单费用 比较(endswith)
   */
  private java.math.BigDecimal otherTransactionFeesEndswith;
  /**
   * 其他订单费用 比较(isnull)
   */
  private Boolean otherTransactionFeesIsnull;
  /**
   * 其他订单费用 比较(isnotnull)
   */
  private Boolean otherTransactionFeesIsnotnull;

  /**
   * 广告费
   */
  private java.math.BigDecimal totalAdsCost;

  /**
   * 最小广告费
   */
  private java.math.BigDecimal totalAdsCostMin;

  /**
   * 最大广告费
   */
  private java.math.BigDecimal totalAdsCostMax;

  /**
   * 广告费 比较(eq)
   */
  private java.math.BigDecimal totalAdsCostEq;
  /**
   * 广告费 比较(neq)
   */
  private java.math.BigDecimal totalAdsCostNeq;
  /**
   * 广告费 比较(gt)
   */
  private java.math.BigDecimal totalAdsCostGt;
  /**
   * 广告费 比较(gte)
   */
  private java.math.BigDecimal totalAdsCostGte;
  /**
   * 广告费 比较(lt)
   */
  private java.math.BigDecimal totalAdsCostLt;
  /**
   * 广告费 比较(lte)
   */
  private java.math.BigDecimal totalAdsCostLte;
  /**
   * 广告费 比较(contains)
   */
  private java.math.BigDecimal totalAdsCostContains;
  /**
   * 广告费 比较(notcontains)
   */
  private java.math.BigDecimal totalAdsCostNotcontains;
  /**
   * 广告费 比较(startswith)
   */
  private java.math.BigDecimal totalAdsCostStartswith;
  /**
   * 广告费 比较(endswith)
   */
  private java.math.BigDecimal totalAdsCostEndswith;
  /**
   * 广告费 比较(isnull)
   */
  private Boolean totalAdsCostIsnull;
  /**
   * 广告费 比较(isnotnull)
   */
  private Boolean totalAdsCostIsnotnull;

  /**
   * SP广告费
   */
  private java.math.BigDecimal adsSpCost;

  /**
   * 最小SP广告费
   */
  private java.math.BigDecimal adsSpCostMin;

  /**
   * 最大SP广告费
   */
  private java.math.BigDecimal adsSpCostMax;

  /**
   * SP广告费 比较(eq)
   */
  private java.math.BigDecimal adsSpCostEq;
  /**
   * SP广告费 比较(neq)
   */
  private java.math.BigDecimal adsSpCostNeq;
  /**
   * SP广告费 比较(gt)
   */
  private java.math.BigDecimal adsSpCostGt;
  /**
   * SP广告费 比较(gte)
   */
  private java.math.BigDecimal adsSpCostGte;
  /**
   * SP广告费 比较(lt)
   */
  private java.math.BigDecimal adsSpCostLt;
  /**
   * SP广告费 比较(lte)
   */
  private java.math.BigDecimal adsSpCostLte;
  /**
   * SP广告费 比较(contains)
   */
  private java.math.BigDecimal adsSpCostContains;
  /**
   * SP广告费 比较(notcontains)
   */
  private java.math.BigDecimal adsSpCostNotcontains;
  /**
   * SP广告费 比较(startswith)
   */
  private java.math.BigDecimal adsSpCostStartswith;
  /**
   * SP广告费 比较(endswith)
   */
  private java.math.BigDecimal adsSpCostEndswith;
  /**
   * SP广告费 比较(isnull)
   */
  private Boolean adsSpCostIsnull;
  /**
   * SP广告费 比较(isnotnull)
   */
  private Boolean adsSpCostIsnotnull;

  /**
   * SB广告费
   */
  private java.math.BigDecimal adsSbCost;

  /**
   * 最小SB广告费
   */
  private java.math.BigDecimal adsSbCostMin;

  /**
   * 最大SB广告费
   */
  private java.math.BigDecimal adsSbCostMax;

  /**
   * SB广告费 比较(eq)
   */
  private java.math.BigDecimal adsSbCostEq;
  /**
   * SB广告费 比较(neq)
   */
  private java.math.BigDecimal adsSbCostNeq;
  /**
   * SB广告费 比较(gt)
   */
  private java.math.BigDecimal adsSbCostGt;
  /**
   * SB广告费 比较(gte)
   */
  private java.math.BigDecimal adsSbCostGte;
  /**
   * SB广告费 比较(lt)
   */
  private java.math.BigDecimal adsSbCostLt;
  /**
   * SB广告费 比较(lte)
   */
  private java.math.BigDecimal adsSbCostLte;
  /**
   * SB广告费 比较(contains)
   */
  private java.math.BigDecimal adsSbCostContains;
  /**
   * SB广告费 比较(notcontains)
   */
  private java.math.BigDecimal adsSbCostNotcontains;
  /**
   * SB广告费 比较(startswith)
   */
  private java.math.BigDecimal adsSbCostStartswith;
  /**
   * SB广告费 比较(endswith)
   */
  private java.math.BigDecimal adsSbCostEndswith;
  /**
   * SB广告费 比较(isnull)
   */
  private Boolean adsSbCostIsnull;
  /**
   * SB广告费 比较(isnotnull)
   */
  private Boolean adsSbCostIsnotnull;

  /**
   * SBV广告费
   */
  private java.math.BigDecimal adsSbvCost;

  /**
   * 最小SBV广告费
   */
  private java.math.BigDecimal adsSbvCostMin;

  /**
   * 最大SBV广告费
   */
  private java.math.BigDecimal adsSbvCostMax;

  /**
   * SBV广告费 比较(eq)
   */
  private java.math.BigDecimal adsSbvCostEq;
  /**
   * SBV广告费 比较(neq)
   */
  private java.math.BigDecimal adsSbvCostNeq;
  /**
   * SBV广告费 比较(gt)
   */
  private java.math.BigDecimal adsSbvCostGt;
  /**
   * SBV广告费 比较(gte)
   */
  private java.math.BigDecimal adsSbvCostGte;
  /**
   * SBV广告费 比较(lt)
   */
  private java.math.BigDecimal adsSbvCostLt;
  /**
   * SBV广告费 比较(lte)
   */
  private java.math.BigDecimal adsSbvCostLte;
  /**
   * SBV广告费 比较(contains)
   */
  private java.math.BigDecimal adsSbvCostContains;
  /**
   * SBV广告费 比较(notcontains)
   */
  private java.math.BigDecimal adsSbvCostNotcontains;
  /**
   * SBV广告费 比较(startswith)
   */
  private java.math.BigDecimal adsSbvCostStartswith;
  /**
   * SBV广告费 比较(endswith)
   */
  private java.math.BigDecimal adsSbvCostEndswith;
  /**
   * SBV广告费 比较(isnull)
   */
  private Boolean adsSbvCostIsnull;
  /**
   * SBV广告费 比较(isnotnull)
   */
  private Boolean adsSbvCostIsnotnull;

  /**
   * SD广告费
   */
  private java.math.BigDecimal adsSdCost;

  /**
   * 最小SD广告费
   */
  private java.math.BigDecimal adsSdCostMin;

  /**
   * 最大SD广告费
   */
  private java.math.BigDecimal adsSdCostMax;

  /**
   * SD广告费 比较(eq)
   */
  private java.math.BigDecimal adsSdCostEq;
  /**
   * SD广告费 比较(neq)
   */
  private java.math.BigDecimal adsSdCostNeq;
  /**
   * SD广告费 比较(gt)
   */
  private java.math.BigDecimal adsSdCostGt;
  /**
   * SD广告费 比较(gte)
   */
  private java.math.BigDecimal adsSdCostGte;
  /**
   * SD广告费 比较(lt)
   */
  private java.math.BigDecimal adsSdCostLt;
  /**
   * SD广告费 比较(lte)
   */
  private java.math.BigDecimal adsSdCostLte;
  /**
   * SD广告费 比较(contains)
   */
  private java.math.BigDecimal adsSdCostContains;
  /**
   * SD广告费 比较(notcontains)
   */
  private java.math.BigDecimal adsSdCostNotcontains;
  /**
   * SD广告费 比较(startswith)
   */
  private java.math.BigDecimal adsSdCostStartswith;
  /**
   * SD广告费 比较(endswith)
   */
  private java.math.BigDecimal adsSdCostEndswith;
  /**
   * SD广告费 比较(isnull)
   */
  private Boolean adsSdCostIsnull;
  /**
   * SD广告费 比较(isnotnull)
   */
  private Boolean adsSdCostIsnotnull;

  /**
   * 差异分摊
   */
  private java.math.BigDecimal sharedCostOfAdvertising;

  /**
   * 最小差异分摊
   */
  private java.math.BigDecimal sharedCostOfAdvertisingMin;

  /**
   * 最大差异分摊
   */
  private java.math.BigDecimal sharedCostOfAdvertisingMax;

  /**
   * 差异分摊 比较(eq)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingEq;
  /**
   * 差异分摊 比较(neq)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingNeq;
  /**
   * 差异分摊 比较(gt)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingGt;
  /**
   * 差异分摊 比较(gte)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingGte;
  /**
   * 差异分摊 比较(lt)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingLt;
  /**
   * 差异分摊 比较(lte)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingLte;
  /**
   * 差异分摊 比较(contains)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingContains;
  /**
   * 差异分摊 比较(notcontains)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingNotcontains;
  /**
   * 差异分摊 比较(startswith)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingStartswith;
  /**
   * 差异分摊 比较(endswith)
   */
  private java.math.BigDecimal sharedCostOfAdvertisingEndswith;
  /**
   * 差异分摊 比较(isnull)
   */
  private Boolean sharedCostOfAdvertisingIsnull;
  /**
   * 差异分摊 比较(isnotnull)
   */
  private Boolean sharedCostOfAdvertisingIsnotnull;

  /**
   * 推广费
   */
  private java.math.BigDecimal promotionFee;

  /**
   * 最小推广费
   */
  private java.math.BigDecimal promotionFeeMin;

  /**
   * 最大推广费
   */
  private java.math.BigDecimal promotionFeeMax;

  /**
   * 推广费 比较(eq)
   */
  private java.math.BigDecimal promotionFeeEq;
  /**
   * 推广费 比较(neq)
   */
  private java.math.BigDecimal promotionFeeNeq;
  /**
   * 推广费 比较(gt)
   */
  private java.math.BigDecimal promotionFeeGt;
  /**
   * 推广费 比较(gte)
   */
  private java.math.BigDecimal promotionFeeGte;
  /**
   * 推广费 比较(lt)
   */
  private java.math.BigDecimal promotionFeeLt;
  /**
   * 推广费 比较(lte)
   */
  private java.math.BigDecimal promotionFeeLte;
  /**
   * 推广费 比较(contains)
   */
  private java.math.BigDecimal promotionFeeContains;
  /**
   * 推广费 比较(notcontains)
   */
  private java.math.BigDecimal promotionFeeNotcontains;
  /**
   * 推广费 比较(startswith)
   */
  private java.math.BigDecimal promotionFeeStartswith;
  /**
   * 推广费 比较(endswith)
   */
  private java.math.BigDecimal promotionFeeEndswith;
  /**
   * 推广费 比较(isnull)
   */
  private Boolean promotionFeeIsnull;
  /**
   * 推广费 比较(isnotnull)
   */
  private Boolean promotionFeeIsnotnull;

  /**
   * 订阅费
   */
  private java.math.BigDecimal sharedSubscriptionFee;

  /**
   * 最小订阅费
   */
  private java.math.BigDecimal sharedSubscriptionFeeMin;

  /**
   * 最大订阅费
   */
  private java.math.BigDecimal sharedSubscriptionFeeMax;

  /**
   * 订阅费 比较(eq)
   */
  private java.math.BigDecimal sharedSubscriptionFeeEq;
  /**
   * 订阅费 比较(neq)
   */
  private java.math.BigDecimal sharedSubscriptionFeeNeq;
  /**
   * 订阅费 比较(gt)
   */
  private java.math.BigDecimal sharedSubscriptionFeeGt;
  /**
   * 订阅费 比较(gte)
   */
  private java.math.BigDecimal sharedSubscriptionFeeGte;
  /**
   * 订阅费 比较(lt)
   */
  private java.math.BigDecimal sharedSubscriptionFeeLt;
  /**
   * 订阅费 比较(lte)
   */
  private java.math.BigDecimal sharedSubscriptionFeeLte;
  /**
   * 订阅费 比较(contains)
   */
  private java.math.BigDecimal sharedSubscriptionFeeContains;
  /**
   * 订阅费 比较(notcontains)
   */
  private java.math.BigDecimal sharedSubscriptionFeeNotcontains;
  /**
   * 订阅费 比较(startswith)
   */
  private java.math.BigDecimal sharedSubscriptionFeeStartswith;
  /**
   * 订阅费 比较(endswith)
   */
  private java.math.BigDecimal sharedSubscriptionFeeEndswith;
  /**
   * 订阅费 比较(isnull)
   */
  private Boolean sharedSubscriptionFeeIsnull;
  /**
   * 订阅费 比较(isnotnull)
   */
  private Boolean sharedSubscriptionFeeIsnotnull;

  /**
   * 秒杀费
   */
  private java.math.BigDecimal sharedLdFee;

  /**
   * 最小秒杀费
   */
  private java.math.BigDecimal sharedLdFeeMin;

  /**
   * 最大秒杀费
   */
  private java.math.BigDecimal sharedLdFeeMax;

  /**
   * 秒杀费 比较(eq)
   */
  private java.math.BigDecimal sharedLdFeeEq;
  /**
   * 秒杀费 比较(neq)
   */
  private java.math.BigDecimal sharedLdFeeNeq;
  /**
   * 秒杀费 比较(gt)
   */
  private java.math.BigDecimal sharedLdFeeGt;
  /**
   * 秒杀费 比较(gte)
   */
  private java.math.BigDecimal sharedLdFeeGte;
  /**
   * 秒杀费 比较(lt)
   */
  private java.math.BigDecimal sharedLdFeeLt;
  /**
   * 秒杀费 比较(lte)
   */
  private java.math.BigDecimal sharedLdFeeLte;
  /**
   * 秒杀费 比较(contains)
   */
  private java.math.BigDecimal sharedLdFeeContains;
  /**
   * 秒杀费 比较(notcontains)
   */
  private java.math.BigDecimal sharedLdFeeNotcontains;
  /**
   * 秒杀费 比较(startswith)
   */
  private java.math.BigDecimal sharedLdFeeStartswith;
  /**
   * 秒杀费 比较(endswith)
   */
  private java.math.BigDecimal sharedLdFeeEndswith;
  /**
   * 秒杀费 比较(isnull)
   */
  private Boolean sharedLdFeeIsnull;
  /**
   * 秒杀费 比较(isnotnull)
   */
  private Boolean sharedLdFeeIsnotnull;

  /**
   * 优惠卷
   */
  private java.math.BigDecimal sharedCouponFee;

  /**
   * 最小优惠卷
   */
  private java.math.BigDecimal sharedCouponFeeMin;

  /**
   * 最大优惠卷
   */
  private java.math.BigDecimal sharedCouponFeeMax;

  /**
   * 优惠卷 比较(eq)
   */
  private java.math.BigDecimal sharedCouponFeeEq;
  /**
   * 优惠卷 比较(neq)
   */
  private java.math.BigDecimal sharedCouponFeeNeq;
  /**
   * 优惠卷 比较(gt)
   */
  private java.math.BigDecimal sharedCouponFeeGt;
  /**
   * 优惠卷 比较(gte)
   */
  private java.math.BigDecimal sharedCouponFeeGte;
  /**
   * 优惠卷 比较(lt)
   */
  private java.math.BigDecimal sharedCouponFeeLt;
  /**
   * 优惠卷 比较(lte)
   */
  private java.math.BigDecimal sharedCouponFeeLte;
  /**
   * 优惠卷 比较(contains)
   */
  private java.math.BigDecimal sharedCouponFeeContains;
  /**
   * 优惠卷 比较(notcontains)
   */
  private java.math.BigDecimal sharedCouponFeeNotcontains;
  /**
   * 优惠卷 比较(startswith)
   */
  private java.math.BigDecimal sharedCouponFeeStartswith;
  /**
   * 优惠卷 比较(endswith)
   */
  private java.math.BigDecimal sharedCouponFeeEndswith;
  /**
   * 优惠卷 比较(isnull)
   */
  private Boolean sharedCouponFeeIsnull;
  /**
   * 优惠卷 比较(isnotnull)
   */
  private Boolean sharedCouponFeeIsnotnull;

  /**
   * 早期评论人计划
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFee;

  /**
   * 最小早期评论人计划
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeMin;

  /**
   * 最大早期评论人计划
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeMax;

  /**
   * 早期评论人计划 比较(eq)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeEq;
  /**
   * 早期评论人计划 比较(neq)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeNeq;
  /**
   * 早期评论人计划 比较(gt)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeGt;
  /**
   * 早期评论人计划 比较(gte)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeGte;
  /**
   * 早期评论人计划 比较(lt)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeLt;
  /**
   * 早期评论人计划 比较(lte)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeLte;
  /**
   * 早期评论人计划 比较(contains)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeContains;
  /**
   * 早期评论人计划 比较(notcontains)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeNotcontains;
  /**
   * 早期评论人计划 比较(startswith)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeStartswith;
  /**
   * 早期评论人计划 比较(endswith)
   */
  private java.math.BigDecimal sharedEarlyReviewerProgramFeeEndswith;
  /**
   * 早期评论人计划 比较(isnull)
   */
  private Boolean sharedEarlyReviewerProgramFeeIsnull;
  /**
   * 早期评论人计划 比较(isnotnull)
   */
  private Boolean sharedEarlyReviewerProgramFeeIsnotnull;

  /**
   * vine
   */
  private java.math.BigDecimal sharedVineFee;

  /**
   * 最小vine
   */
  private java.math.BigDecimal sharedVineFeeMin;

  /**
   * 最大vine
   */
  private java.math.BigDecimal sharedVineFeeMax;

  /**
   * vine 比较(eq)
   */
  private java.math.BigDecimal sharedVineFeeEq;
  /**
   * vine 比较(neq)
   */
  private java.math.BigDecimal sharedVineFeeNeq;
  /**
   * vine 比较(gt)
   */
  private java.math.BigDecimal sharedVineFeeGt;
  /**
   * vine 比较(gte)
   */
  private java.math.BigDecimal sharedVineFeeGte;
  /**
   * vine 比较(lt)
   */
  private java.math.BigDecimal sharedVineFeeLt;
  /**
   * vine 比较(lte)
   */
  private java.math.BigDecimal sharedVineFeeLte;
  /**
   * vine 比较(contains)
   */
  private java.math.BigDecimal sharedVineFeeContains;
  /**
   * vine 比较(notcontains)
   */
  private java.math.BigDecimal sharedVineFeeNotcontains;
  /**
   * vine 比较(startswith)
   */
  private java.math.BigDecimal sharedVineFeeStartswith;
  /**
   * vine 比较(endswith)
   */
  private java.math.BigDecimal sharedVineFeeEndswith;
  /**
   * vine 比较(isnull)
   */
  private Boolean sharedVineFeeIsnull;
  /**
   * vine 比较(isnotnull)
   */
  private Boolean sharedVineFeeIsnotnull;

  /**
   * FBA仓储费
   */
  private java.math.BigDecimal totalStorageFee;

  /**
   * 最小FBA仓储费
   */
  private java.math.BigDecimal totalStorageFeeMin;

  /**
   * 最大FBA仓储费
   */
  private java.math.BigDecimal totalStorageFeeMax;

  /**
   * FBA仓储费 比较(eq)
   */
  private java.math.BigDecimal totalStorageFeeEq;
  /**
   * FBA仓储费 比较(neq)
   */
  private java.math.BigDecimal totalStorageFeeNeq;
  /**
   * FBA仓储费 比较(gt)
   */
  private java.math.BigDecimal totalStorageFeeGt;
  /**
   * FBA仓储费 比较(gte)
   */
  private java.math.BigDecimal totalStorageFeeGte;
  /**
   * FBA仓储费 比较(lt)
   */
  private java.math.BigDecimal totalStorageFeeLt;
  /**
   * FBA仓储费 比较(lte)
   */
  private java.math.BigDecimal totalStorageFeeLte;
  /**
   * FBA仓储费 比较(contains)
   */
  private java.math.BigDecimal totalStorageFeeContains;
  /**
   * FBA仓储费 比较(notcontains)
   */
  private java.math.BigDecimal totalStorageFeeNotcontains;
  /**
   * FBA仓储费 比较(startswith)
   */
  private java.math.BigDecimal totalStorageFeeStartswith;
  /**
   * FBA仓储费 比较(endswith)
   */
  private java.math.BigDecimal totalStorageFeeEndswith;
  /**
   * FBA仓储费 比较(isnull)
   */
  private Boolean totalStorageFeeIsnull;
  /**
   * FBA仓储费 比较(isnotnull)
   */
  private Boolean totalStorageFeeIsnotnull;

  /**
   * 月度仓库费
   */
  private java.math.BigDecimal fbaStorageFee;

  /**
   * 最小月度仓库费
   */
  private java.math.BigDecimal fbaStorageFeeMin;

  /**
   * 最大月度仓库费
   */
  private java.math.BigDecimal fbaStorageFeeMax;

  /**
   * 月度仓库费 比较(eq)
   */
  private java.math.BigDecimal fbaStorageFeeEq;
  /**
   * 月度仓库费 比较(neq)
   */
  private java.math.BigDecimal fbaStorageFeeNeq;
  /**
   * 月度仓库费 比较(gt)
   */
  private java.math.BigDecimal fbaStorageFeeGt;
  /**
   * 月度仓库费 比较(gte)
   */
  private java.math.BigDecimal fbaStorageFeeGte;
  /**
   * 月度仓库费 比较(lt)
   */
  private java.math.BigDecimal fbaStorageFeeLt;
  /**
   * 月度仓库费 比较(lte)
   */
  private java.math.BigDecimal fbaStorageFeeLte;
  /**
   * 月度仓库费 比较(contains)
   */
  private java.math.BigDecimal fbaStorageFeeContains;
  /**
   * 月度仓库费 比较(notcontains)
   */
  private java.math.BigDecimal fbaStorageFeeNotcontains;
  /**
   * 月度仓库费 比较(startswith)
   */
  private java.math.BigDecimal fbaStorageFeeStartswith;
  /**
   * 月度仓库费 比较(endswith)
   */
  private java.math.BigDecimal fbaStorageFeeEndswith;
  /**
   * 月度仓库费 比较(isnull)
   */
  private Boolean fbaStorageFeeIsnull;
  /**
   * 月度仓库费 比较(isnotnull)
   */
  private Boolean fbaStorageFeeIsnotnull;

  /**
   * 月度仓储费差异
   */
  private java.math.BigDecimal sharedFbaStorageFee;

  /**
   * 最小月度仓储费差异
   */
  private java.math.BigDecimal sharedFbaStorageFeeMin;

  /**
   * 最大月度仓储费差异
   */
  private java.math.BigDecimal sharedFbaStorageFeeMax;

  /**
   * 月度仓储费差异 比较(eq)
   */
  private java.math.BigDecimal sharedFbaStorageFeeEq;
  /**
   * 月度仓储费差异 比较(neq)
   */
  private java.math.BigDecimal sharedFbaStorageFeeNeq;
  /**
   * 月度仓储费差异 比较(gt)
   */
  private java.math.BigDecimal sharedFbaStorageFeeGt;
  /**
   * 月度仓储费差异 比较(gte)
   */
  private java.math.BigDecimal sharedFbaStorageFeeGte;
  /**
   * 月度仓储费差异 比较(lt)
   */
  private java.math.BigDecimal sharedFbaStorageFeeLt;
  /**
   * 月度仓储费差异 比较(lte)
   */
  private java.math.BigDecimal sharedFbaStorageFeeLte;
  /**
   * 月度仓储费差异 比较(contains)
   */
  private java.math.BigDecimal sharedFbaStorageFeeContains;
  /**
   * 月度仓储费差异 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaStorageFeeNotcontains;
  /**
   * 月度仓储费差异 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaStorageFeeStartswith;
  /**
   * 月度仓储费差异 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaStorageFeeEndswith;
  /**
   * 月度仓储费差异 比较(isnull)
   */
  private Boolean sharedFbaStorageFeeIsnull;
  /**
   * 月度仓储费差异 比较(isnotnull)
   */
  private Boolean sharedFbaStorageFeeIsnotnull;

  /**
   * 长期仓储费
   */
  private java.math.BigDecimal longTermStorageFee;

  /**
   * 最小长期仓储费
   */
  private java.math.BigDecimal longTermStorageFeeMin;

  /**
   * 最大长期仓储费
   */
  private java.math.BigDecimal longTermStorageFeeMax;

  /**
   * 长期仓储费 比较(eq)
   */
  private java.math.BigDecimal longTermStorageFeeEq;
  /**
   * 长期仓储费 比较(neq)
   */
  private java.math.BigDecimal longTermStorageFeeNeq;
  /**
   * 长期仓储费 比较(gt)
   */
  private java.math.BigDecimal longTermStorageFeeGt;
  /**
   * 长期仓储费 比较(gte)
   */
  private java.math.BigDecimal longTermStorageFeeGte;
  /**
   * 长期仓储费 比较(lt)
   */
  private java.math.BigDecimal longTermStorageFeeLt;
  /**
   * 长期仓储费 比较(lte)
   */
  private java.math.BigDecimal longTermStorageFeeLte;
  /**
   * 长期仓储费 比较(contains)
   */
  private java.math.BigDecimal longTermStorageFeeContains;
  /**
   * 长期仓储费 比较(notcontains)
   */
  private java.math.BigDecimal longTermStorageFeeNotcontains;
  /**
   * 长期仓储费 比较(startswith)
   */
  private java.math.BigDecimal longTermStorageFeeStartswith;
  /**
   * 长期仓储费 比较(endswith)
   */
  private java.math.BigDecimal longTermStorageFeeEndswith;
  /**
   * 长期仓储费 比较(isnull)
   */
  private Boolean longTermStorageFeeIsnull;
  /**
   * 长期仓储费 比较(isnotnull)
   */
  private Boolean longTermStorageFeeIsnotnull;

  /**
   * 长期仓储费差异
   */
  private java.math.BigDecimal sharedLongTermStorageFee;

  /**
   * 最小长期仓储费差异
   */
  private java.math.BigDecimal sharedLongTermStorageFeeMin;

  /**
   * 最大长期仓储费差异
   */
  private java.math.BigDecimal sharedLongTermStorageFeeMax;

  /**
   * 长期仓储费差异 比较(eq)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeEq;
  /**
   * 长期仓储费差异 比较(neq)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeNeq;
  /**
   * 长期仓储费差异 比较(gt)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeGt;
  /**
   * 长期仓储费差异 比较(gte)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeGte;
  /**
   * 长期仓储费差异 比较(lt)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeLt;
  /**
   * 长期仓储费差异 比较(lte)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeLte;
  /**
   * 长期仓储费差异 比较(contains)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeContains;
  /**
   * 长期仓储费差异 比较(notcontains)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeNotcontains;
  /**
   * 长期仓储费差异 比较(startswith)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeStartswith;
  /**
   * 长期仓储费差异 比较(endswith)
   */
  private java.math.BigDecimal sharedLongTermStorageFeeEndswith;
  /**
   * 长期仓储费差异 比较(isnull)
   */
  private Boolean sharedLongTermStorageFeeIsnull;
  /**
   * 长期仓储费差异 比较(isnotnull)
   */
  private Boolean sharedLongTermStorageFeeIsnotnull;

  /**
   * 库存续订费用
   */
  private java.math.BigDecimal sharedStorageRenewalBilling;

  /**
   * 最小库存续订费用
   */
  private java.math.BigDecimal sharedStorageRenewalBillingMin;

  /**
   * 最大库存续订费用
   */
  private java.math.BigDecimal sharedStorageRenewalBillingMax;

  /**
   * 库存续订费用 比较(eq)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingEq;
  /**
   * 库存续订费用 比较(neq)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingNeq;
  /**
   * 库存续订费用 比较(gt)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingGt;
  /**
   * 库存续订费用 比较(gte)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingGte;
  /**
   * 库存续订费用 比较(lt)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingLt;
  /**
   * 库存续订费用 比较(lte)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingLte;
  /**
   * 库存续订费用 比较(contains)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingContains;
  /**
   * 库存续订费用 比较(notcontains)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingNotcontains;
  /**
   * 库存续订费用 比较(startswith)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingStartswith;
  /**
   * 库存续订费用 比较(endswith)
   */
  private java.math.BigDecimal sharedStorageRenewalBillingEndswith;
  /**
   * 库存续订费用 比较(isnull)
   */
  private Boolean sharedStorageRenewalBillingIsnull;
  /**
   * 库存续订费用 比较(isnotnull)
   */
  private Boolean sharedStorageRenewalBillingIsnotnull;

  /**
   * FBA销毁费
   */
  private java.math.BigDecimal sharedFbaDisposalFee;

  /**
   * 最小FBA销毁费
   */
  private java.math.BigDecimal sharedFbaDisposalFeeMin;

  /**
   * 最大FBA销毁费
   */
  private java.math.BigDecimal sharedFbaDisposalFeeMax;

  /**
   * FBA销毁费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeEq;
  /**
   * FBA销毁费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeNeq;
  /**
   * FBA销毁费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeGt;
  /**
   * FBA销毁费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeGte;
  /**
   * FBA销毁费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeLt;
  /**
   * FBA销毁费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeLte;
  /**
   * FBA销毁费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeContains;
  /**
   * FBA销毁费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeNotcontains;
  /**
   * FBA销毁费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeStartswith;
  /**
   * FBA销毁费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaDisposalFeeEndswith;
  /**
   * FBA销毁费 比较(isnull)
   */
  private Boolean sharedFbaDisposalFeeIsnull;
  /**
   * FBA销毁费 比较(isnotnull)
   */
  private Boolean sharedFbaDisposalFeeIsnotnull;

  /**
   * FBA移除费
   */
  private java.math.BigDecimal sharedFbaRemovalFee;

  /**
   * 最小FBA移除费
   */
  private java.math.BigDecimal sharedFbaRemovalFeeMin;

  /**
   * 最大FBA移除费
   */
  private java.math.BigDecimal sharedFbaRemovalFeeMax;

  /**
   * FBA移除费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeEq;
  /**
   * FBA移除费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeNeq;
  /**
   * FBA移除费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeGt;
  /**
   * FBA移除费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeGte;
  /**
   * FBA移除费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeLt;
  /**
   * FBA移除费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeLte;
  /**
   * FBA移除费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeContains;
  /**
   * FBA移除费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeNotcontains;
  /**
   * FBA移除费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeStartswith;
  /**
   * FBA移除费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaRemovalFeeEndswith;
  /**
   * FBA移除费 比较(isnull)
   */
  private Boolean sharedFbaRemovalFeeIsnull;
  /**
   * FBA移除费 比较(isnotnull)
   */
  private Boolean sharedFbaRemovalFeeIsnotnull;

  /**
   * 入仓手续费
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFee;

  /**
   * 最小入仓手续费
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeMin;

  /**
   * 最大入仓手续费
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeMax;

  /**
   * 入仓手续费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeEq;
  /**
   * 入仓手续费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeNeq;
  /**
   * 入仓手续费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeGt;
  /**
   * 入仓手续费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeGte;
  /**
   * 入仓手续费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeLt;
  /**
   * 入仓手续费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeLte;
  /**
   * 入仓手续费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeContains;
  /**
   * 入仓手续费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeNotcontains;
  /**
   * 入仓手续费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeStartswith;
  /**
   * 入仓手续费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaInboundTransportationProgramFeeEndswith;
  /**
   * 入仓手续费 比较(isnull)
   */
  private Boolean sharedFbaInboundTransportationProgramFeeIsnull;
  /**
   * 入仓手续费 比较(isnotnull)
   */
  private Boolean sharedFbaInboundTransportationProgramFeeIsnotnull;

  /**
   * 标签费
   */
  private java.math.BigDecimal sharedLabelingFee;

  /**
   * 最小标签费
   */
  private java.math.BigDecimal sharedLabelingFeeMin;

  /**
   * 最大标签费
   */
  private java.math.BigDecimal sharedLabelingFeeMax;

  /**
   * 标签费 比较(eq)
   */
  private java.math.BigDecimal sharedLabelingFeeEq;
  /**
   * 标签费 比较(neq)
   */
  private java.math.BigDecimal sharedLabelingFeeNeq;
  /**
   * 标签费 比较(gt)
   */
  private java.math.BigDecimal sharedLabelingFeeGt;
  /**
   * 标签费 比较(gte)
   */
  private java.math.BigDecimal sharedLabelingFeeGte;
  /**
   * 标签费 比较(lt)
   */
  private java.math.BigDecimal sharedLabelingFeeLt;
  /**
   * 标签费 比较(lte)
   */
  private java.math.BigDecimal sharedLabelingFeeLte;
  /**
   * 标签费 比较(contains)
   */
  private java.math.BigDecimal sharedLabelingFeeContains;
  /**
   * 标签费 比较(notcontains)
   */
  private java.math.BigDecimal sharedLabelingFeeNotcontains;
  /**
   * 标签费 比较(startswith)
   */
  private java.math.BigDecimal sharedLabelingFeeStartswith;
  /**
   * 标签费 比较(endswith)
   */
  private java.math.BigDecimal sharedLabelingFeeEndswith;
  /**
   * 标签费 比较(isnull)
   */
  private Boolean sharedLabelingFeeIsnull;
  /**
   * 标签费 比较(isnotnull)
   */
  private Boolean sharedLabelingFeeIsnotnull;

  /**
   * 塑料包装费
   */
  private java.math.BigDecimal sharedPolybaggingFee;

  /**
   * 最小塑料包装费
   */
  private java.math.BigDecimal sharedPolybaggingFeeMin;

  /**
   * 最大塑料包装费
   */
  private java.math.BigDecimal sharedPolybaggingFeeMax;

  /**
   * 塑料包装费 比较(eq)
   */
  private java.math.BigDecimal sharedPolybaggingFeeEq;
  /**
   * 塑料包装费 比较(neq)
   */
  private java.math.BigDecimal sharedPolybaggingFeeNeq;
  /**
   * 塑料包装费 比较(gt)
   */
  private java.math.BigDecimal sharedPolybaggingFeeGt;
  /**
   * 塑料包装费 比较(gte)
   */
  private java.math.BigDecimal sharedPolybaggingFeeGte;
  /**
   * 塑料包装费 比较(lt)
   */
  private java.math.BigDecimal sharedPolybaggingFeeLt;
  /**
   * 塑料包装费 比较(lte)
   */
  private java.math.BigDecimal sharedPolybaggingFeeLte;
  /**
   * 塑料包装费 比较(contains)
   */
  private java.math.BigDecimal sharedPolybaggingFeeContains;
  /**
   * 塑料包装费 比较(notcontains)
   */
  private java.math.BigDecimal sharedPolybaggingFeeNotcontains;
  /**
   * 塑料包装费 比较(startswith)
   */
  private java.math.BigDecimal sharedPolybaggingFeeStartswith;
  /**
   * 塑料包装费 比较(endswith)
   */
  private java.math.BigDecimal sharedPolybaggingFeeEndswith;
  /**
   * 塑料包装费 比较(isnull)
   */
  private Boolean sharedPolybaggingFeeIsnull;
  /**
   * 塑料包装费 比较(isnotnull)
   */
  private Boolean sharedPolybaggingFeeIsnotnull;

  /**
   * 泡沫包装费
   */
  private java.math.BigDecimal sharedBubblewrapFee;

  /**
   * 最小泡沫包装费
   */
  private java.math.BigDecimal sharedBubblewrapFeeMin;

  /**
   * 最大泡沫包装费
   */
  private java.math.BigDecimal sharedBubblewrapFeeMax;

  /**
   * 泡沫包装费 比较(eq)
   */
  private java.math.BigDecimal sharedBubblewrapFeeEq;
  /**
   * 泡沫包装费 比较(neq)
   */
  private java.math.BigDecimal sharedBubblewrapFeeNeq;
  /**
   * 泡沫包装费 比较(gt)
   */
  private java.math.BigDecimal sharedBubblewrapFeeGt;
  /**
   * 泡沫包装费 比较(gte)
   */
  private java.math.BigDecimal sharedBubblewrapFeeGte;
  /**
   * 泡沫包装费 比较(lt)
   */
  private java.math.BigDecimal sharedBubblewrapFeeLt;
  /**
   * 泡沫包装费 比较(lte)
   */
  private java.math.BigDecimal sharedBubblewrapFeeLte;
  /**
   * 泡沫包装费 比较(contains)
   */
  private java.math.BigDecimal sharedBubblewrapFeeContains;
  /**
   * 泡沫包装费 比较(notcontains)
   */
  private java.math.BigDecimal sharedBubblewrapFeeNotcontains;
  /**
   * 泡沫包装费 比较(startswith)
   */
  private java.math.BigDecimal sharedBubblewrapFeeStartswith;
  /**
   * 泡沫包装费 比较(endswith)
   */
  private java.math.BigDecimal sharedBubblewrapFeeEndswith;
  /**
   * 泡沫包装费 比较(isnull)
   */
  private Boolean sharedBubblewrapFeeIsnull;
  /**
   * 泡沫包装费 比较(isnotnull)
   */
  private Boolean sharedBubblewrapFeeIsnotnull;

  /**
   * 胶带费
   */
  private java.math.BigDecimal sharedTapingFee;

  /**
   * 最小胶带费
   */
  private java.math.BigDecimal sharedTapingFeeMin;

  /**
   * 最大胶带费
   */
  private java.math.BigDecimal sharedTapingFeeMax;

  /**
   * 胶带费 比较(eq)
   */
  private java.math.BigDecimal sharedTapingFeeEq;
  /**
   * 胶带费 比较(neq)
   */
  private java.math.BigDecimal sharedTapingFeeNeq;
  /**
   * 胶带费 比较(gt)
   */
  private java.math.BigDecimal sharedTapingFeeGt;
  /**
   * 胶带费 比较(gte)
   */
  private java.math.BigDecimal sharedTapingFeeGte;
  /**
   * 胶带费 比较(lt)
   */
  private java.math.BigDecimal sharedTapingFeeLt;
  /**
   * 胶带费 比较(lte)
   */
  private java.math.BigDecimal sharedTapingFeeLte;
  /**
   * 胶带费 比较(contains)
   */
  private java.math.BigDecimal sharedTapingFeeContains;
  /**
   * 胶带费 比较(notcontains)
   */
  private java.math.BigDecimal sharedTapingFeeNotcontains;
  /**
   * 胶带费 比较(startswith)
   */
  private java.math.BigDecimal sharedTapingFeeStartswith;
  /**
   * 胶带费 比较(endswith)
   */
  private java.math.BigDecimal sharedTapingFeeEndswith;
  /**
   * 胶带费 比较(isnull)
   */
  private Boolean sharedTapingFeeIsnull;
  /**
   * 胶带费 比较(isnotnull)
   */
  private Boolean sharedTapingFeeIsnotnull;

  /**
   * FBA卖家退回费
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFee;

  /**
   * 最小FBA卖家退回费
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeMin;

  /**
   * 最大FBA卖家退回费
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeMax;

  /**
   * FBA卖家退回费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeEq;
  /**
   * FBA卖家退回费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeNeq;
  /**
   * FBA卖家退回费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeGt;
  /**
   * FBA卖家退回费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeGte;
  /**
   * FBA卖家退回费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeLt;
  /**
   * FBA卖家退回费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeLte;
  /**
   * FBA卖家退回费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeContains;
  /**
   * FBA卖家退回费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeNotcontains;
  /**
   * FBA卖家退回费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeStartswith;
  /**
   * FBA卖家退回费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaCustomerReturnFeeEndswith;
  /**
   * FBA卖家退回费 比较(isnull)
   */
  private Boolean sharedFbaCustomerReturnFeeIsnull;
  /**
   * FBA卖家退回费 比较(isnotnull)
   */
  private Boolean sharedFbaCustomerReturnFeeIsnotnull;

  /**
   * 计划外服务费
   */
  private java.math.BigDecimal sharedFbaInboundDefectFee;

  /**
   * 最小计划外服务费
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeMin;

  /**
   * 最大计划外服务费
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeMax;

  /**
   * 计划外服务费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeEq;
  /**
   * 计划外服务费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeNeq;
  /**
   * 计划外服务费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeGt;
  /**
   * 计划外服务费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeGte;
  /**
   * 计划外服务费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeLt;
  /**
   * 计划外服务费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeLte;
  /**
   * 计划外服务费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeContains;
  /**
   * 计划外服务费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeNotcontains;
  /**
   * 计划外服务费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeStartswith;
  /**
   * 计划外服务费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaInboundDefectFeeEndswith;
  /**
   * 计划外服务费 比较(isnull)
   */
  private Boolean sharedFbaInboundDefectFeeIsnull;
  /**
   * 计划外服务费 比较(isnotnull)
   */
  private Boolean sharedFbaInboundDefectFeeIsnotnull;

  /**
   * 超量仓储费
   */
  private java.math.BigDecimal sharedFbaOverageFee;

  /**
   * 最小超量仓储费
   */
  private java.math.BigDecimal sharedFbaOverageFeeMin;

  /**
   * 最大超量仓储费
   */
  private java.math.BigDecimal sharedFbaOverageFeeMax;

  /**
   * 超量仓储费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaOverageFeeEq;
  /**
   * 超量仓储费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaOverageFeeNeq;
  /**
   * 超量仓储费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaOverageFeeGt;
  /**
   * 超量仓储费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaOverageFeeGte;
  /**
   * 超量仓储费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaOverageFeeLt;
  /**
   * 超量仓储费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaOverageFeeLte;
  /**
   * 超量仓储费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaOverageFeeContains;
  /**
   * 超量仓储费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaOverageFeeNotcontains;
  /**
   * 超量仓储费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaOverageFeeStartswith;
  /**
   * 超量仓储费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaOverageFeeEndswith;
  /**
   * 超量仓储费 比较(isnull)
   */
  private Boolean sharedFbaOverageFeeIsnull;
  /**
   * 超量仓储费 比较(isnotnull)
   */
  private Boolean sharedFbaOverageFeeIsnotnull;

  /**
   * 合作承运费
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFee;

  /**
   * 最小合作承运费
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeMin;

  /**
   * 最大合作承运费
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeMax;

  /**
   * 合作承运费 比较(eq)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeEq;
  /**
   * 合作承运费 比较(neq)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeNeq;
  /**
   * 合作承运费 比较(gt)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeGt;
  /**
   * 合作承运费 比较(gte)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeGte;
  /**
   * 合作承运费 比较(lt)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeLt;
  /**
   * 合作承运费 比较(lte)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeLte;
  /**
   * 合作承运费 比较(contains)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeContains;
  /**
   * 合作承运费 比较(notcontains)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeNotcontains;
  /**
   * 合作承运费 比较(startswith)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeStartswith;
  /**
   * 合作承运费 比较(endswith)
   */
  private java.math.BigDecimal sharedAmazonPartneredCarrierShipmentFeeEndswith;
  /**
   * 合作承运费 比较(isnull)
   */
  private Boolean sharedAmazonPartneredCarrierShipmentFeeIsnull;
  /**
   * 合作承运费 比较(isnotnull)
   */
  private Boolean sharedAmazonPartneredCarrierShipmentFeeIsnotnull;

  /**
   * 合仓费
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFee;

  /**
   * 最小合仓费
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeMin;

  /**
   * 最大合仓费
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeMax;

  /**
   * 合仓费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeEq;
  /**
   * 合仓费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeNeq;
  /**
   * 合仓费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeGt;
  /**
   * 合仓费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeGte;
  /**
   * 合仓费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeLt;
  /**
   * 合仓费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeLte;
  /**
   * 合仓费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeContains;
  /**
   * 合仓费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeNotcontains;
  /**
   * 合仓费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeStartswith;
  /**
   * 合仓费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaInboundConvenienceFeeEndswith;
  /**
   * 合仓费 比较(isnull)
   */
  private Boolean sharedFbaInboundConvenienceFeeIsnull;
  /**
   * 合仓费 比较(isnotnull)
   */
  private Boolean sharedFbaInboundConvenienceFeeIsnotnull;

  /**
   * 库存调整费用
   */
  private java.math.BigDecimal sharedItemFeeAdjustment;

  /**
   * 最小库存调整费用
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentMin;

  /**
   * 最大库存调整费用
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentMax;

  /**
   * 库存调整费用 比较(eq)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentEq;
  /**
   * 库存调整费用 比较(neq)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentNeq;
  /**
   * 库存调整费用 比较(gt)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentGt;
  /**
   * 库存调整费用 比较(gte)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentGte;
  /**
   * 库存调整费用 比较(lt)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentLt;
  /**
   * 库存调整费用 比较(lte)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentLte;
  /**
   * 库存调整费用 比较(contains)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentContains;
  /**
   * 库存调整费用 比较(notcontains)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentNotcontains;
  /**
   * 库存调整费用 比较(startswith)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentStartswith;
  /**
   * 库存调整费用 比较(endswith)
   */
  private java.math.BigDecimal sharedItemFeeAdjustmentEndswith;
  /**
   * 库存调整费用 比较(isnull)
   */
  private Boolean sharedItemFeeAdjustmentIsnull;
  /**
   * 库存调整费用 比较(isnotnull)
   */
  private Boolean sharedItemFeeAdjustmentIsnotnull;

  /**
   * 其他仓储费
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFees;

  /**
   * 最小其他仓储费
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesMin;

  /**
   * 最大其他仓储费
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesMax;

  /**
   * 其他仓储费 比较(eq)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesEq;
  /**
   * 其他仓储费 比较(neq)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesNeq;
  /**
   * 其他仓储费 比较(gt)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesGt;
  /**
   * 其他仓储费 比较(gte)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesGte;
  /**
   * 其他仓储费 比较(lt)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesLt;
  /**
   * 其他仓储费 比较(lte)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesLte;
  /**
   * 其他仓储费 比较(contains)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesContains;
  /**
   * 其他仓储费 比较(notcontains)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesNotcontains;
  /**
   * 其他仓储费 比较(startswith)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesStartswith;
  /**
   * 其他仓储费 比较(endswith)
   */
  private java.math.BigDecimal sharedOtherFbaInventoryFeesEndswith;
  /**
   * 其他仓储费 比较(isnull)
   */
  private Boolean sharedOtherFbaInventoryFeesIsnull;
  /**
   * 其他仓储费 比较(isnotnull)
   */
  private Boolean sharedOtherFbaInventoryFeesIsnotnull;

  /**
   * 月仓储费-本月计提
   */
  private java.math.BigDecimal fbaStorageFeeAccrual;

  /**
   * 最小月仓储费-本月计提
   */
  private java.math.BigDecimal fbaStorageFeeAccrualMin;

  /**
   * 最大月仓储费-本月计提
   */
  private java.math.BigDecimal fbaStorageFeeAccrualMax;

  /**
   * 月仓储费-本月计提 比较(eq)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualEq;
  /**
   * 月仓储费-本月计提 比较(neq)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualNeq;
  /**
   * 月仓储费-本月计提 比较(gt)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualGt;
  /**
   * 月仓储费-本月计提 比较(gte)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualGte;
  /**
   * 月仓储费-本月计提 比较(lt)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualLt;
  /**
   * 月仓储费-本月计提 比较(lte)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualLte;
  /**
   * 月仓储费-本月计提 比较(contains)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualContains;
  /**
   * 月仓储费-本月计提 比较(notcontains)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualNotcontains;
  /**
   * 月仓储费-本月计提 比较(startswith)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualStartswith;
  /**
   * 月仓储费-本月计提 比较(endswith)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualEndswith;
  /**
   * 月仓储费-本月计提 比较(isnull)
   */
  private Boolean fbaStorageFeeAccrualIsnull;
  /**
   * 月仓储费-本月计提 比较(isnotnull)
   */
  private Boolean fbaStorageFeeAccrualIsnotnull;

  /**
   * 月仓储费-上月冲销
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifference;

  /**
   * 最小月仓储费-上月冲销
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceMin;

  /**
   * 最大月仓储费-上月冲销
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceMax;

  /**
   * 月仓储费-上月冲销 比较(eq)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceEq;
  /**
   * 月仓储费-上月冲销 比较(neq)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceNeq;
  /**
   * 月仓储费-上月冲销 比较(gt)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceGt;
  /**
   * 月仓储费-上月冲销 比较(gte)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceGte;
  /**
   * 月仓储费-上月冲销 比较(lt)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceLt;
  /**
   * 月仓储费-上月冲销 比较(lte)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceLte;
  /**
   * 月仓储费-上月冲销 比较(contains)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceContains;
  /**
   * 月仓储费-上月冲销 比较(notcontains)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceNotcontains;
  /**
   * 月仓储费-上月冲销 比较(startswith)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceStartswith;
  /**
   * 月仓储费-上月冲销 比较(endswith)
   */
  private java.math.BigDecimal fbaStorageFeeAccrualDifferenceEndswith;
  /**
   * 月仓储费-上月冲销 比较(isnull)
   */
  private Boolean fbaStorageFeeAccrualDifferenceIsnull;
  /**
   * 月仓储费-上月冲销 比较(isnotnull)
   */
  private Boolean fbaStorageFeeAccrualDifferenceIsnotnull;

  /**
   * 长期仓储费-本月计提
   */
  private java.math.BigDecimal longTermStorageFeeAccrual;

  /**
   * 最小长期仓储费-本月计提
   */
  private java.math.BigDecimal longTermStorageFeeAccrualMin;

  /**
   * 最大长期仓储费-本月计提
   */
  private java.math.BigDecimal longTermStorageFeeAccrualMax;

  /**
   * 长期仓储费-本月计提 比较(eq)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualEq;
  /**
   * 长期仓储费-本月计提 比较(neq)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualNeq;
  /**
   * 长期仓储费-本月计提 比较(gt)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualGt;
  /**
   * 长期仓储费-本月计提 比较(gte)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualGte;
  /**
   * 长期仓储费-本月计提 比较(lt)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualLt;
  /**
   * 长期仓储费-本月计提 比较(lte)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualLte;
  /**
   * 长期仓储费-本月计提 比较(contains)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualContains;
  /**
   * 长期仓储费-本月计提 比较(notcontains)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualNotcontains;
  /**
   * 长期仓储费-本月计提 比较(startswith)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualStartswith;
  /**
   * 长期仓储费-本月计提 比较(endswith)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualEndswith;
  /**
   * 长期仓储费-本月计提 比较(isnull)
   */
  private Boolean longTermStorageFeeAccrualIsnull;
  /**
   * 长期仓储费-本月计提 比较(isnotnull)
   */
  private Boolean longTermStorageFeeAccrualIsnotnull;

  /**
   * 长期仓储费-上月冲销
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifference;

  /**
   * 最小长期仓储费-上月冲销
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceMin;

  /**
   * 最大长期仓储费-上月冲销
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceMax;

  /**
   * 长期仓储费-上月冲销 比较(eq)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceEq;
  /**
   * 长期仓储费-上月冲销 比较(neq)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceNeq;
  /**
   * 长期仓储费-上月冲销 比较(gt)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceGt;
  /**
   * 长期仓储费-上月冲销 比较(gte)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceGte;
  /**
   * 长期仓储费-上月冲销 比较(lt)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceLt;
  /**
   * 长期仓储费-上月冲销 比较(lte)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceLte;
  /**
   * 长期仓储费-上月冲销 比较(contains)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceContains;
  /**
   * 长期仓储费-上月冲销 比较(notcontains)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceNotcontains;
  /**
   * 长期仓储费-上月冲销 比较(startswith)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceStartswith;
  /**
   * 长期仓储费-上月冲销 比较(endswith)
   */
  private java.math.BigDecimal longTermStorageFeeAccrualDifferenceEndswith;
  /**
   * 长期仓储费-上月冲销 比较(isnull)
   */
  private Boolean longTermStorageFeeAccrualDifferenceIsnull;
  /**
   * 长期仓储费-上月冲销 比较(isnotnull)
   */
  private Boolean longTermStorageFeeAccrualDifferenceIsnotnull;

  /**
   * FBA国际物流货运费
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFee;

  /**
   * 最小FBA国际物流货运费
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeMin;

  /**
   * 最大FBA国际物流货运费
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeMax;

  /**
   * FBA国际物流货运费 比较(eq)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeEq;
  /**
   * FBA国际物流货运费 比较(neq)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeNeq;
  /**
   * FBA国际物流货运费 比较(gt)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeGt;
  /**
   * FBA国际物流货运费 比较(gte)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeGte;
  /**
   * FBA国际物流货运费 比较(lt)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeLt;
  /**
   * FBA国际物流货运费 比较(lte)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeLte;
  /**
   * FBA国际物流货运费 比较(contains)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeContains;
  /**
   * FBA国际物流货运费 比较(notcontains)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeNotcontains;
  /**
   * FBA国际物流货运费 比较(startswith)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeStartswith;
  /**
   * FBA国际物流货运费 比较(endswith)
   */
  private java.math.BigDecimal sharedFbaIntegerernationalInboundFeeEndswith;
  /**
   * FBA国际物流货运费 比较(isnull)
   */
  private Boolean sharedFbaIntegerernationalInboundFeeIsnull;
  /**
   * FBA国际物流货运费 比较(isnotnull)
   */
  private Boolean sharedFbaIntegerernationalInboundFeeIsnotnull;

  /**
   * 调整费用
   */
  private java.math.BigDecimal adjustments;

  /**
   * 最小调整费用
   */
  private java.math.BigDecimal adjustmentsMin;

  /**
   * 最大调整费用
   */
  private java.math.BigDecimal adjustmentsMax;

  /**
   * 调整费用 比较(eq)
   */
  private java.math.BigDecimal adjustmentsEq;
  /**
   * 调整费用 比较(neq)
   */
  private java.math.BigDecimal adjustmentsNeq;
  /**
   * 调整费用 比较(gt)
   */
  private java.math.BigDecimal adjustmentsGt;
  /**
   * 调整费用 比较(gte)
   */
  private java.math.BigDecimal adjustmentsGte;
  /**
   * 调整费用 比较(lt)
   */
  private java.math.BigDecimal adjustmentsLt;
  /**
   * 调整费用 比较(lte)
   */
  private java.math.BigDecimal adjustmentsLte;
  /**
   * 调整费用 比较(contains)
   */
  private java.math.BigDecimal adjustmentsContains;
  /**
   * 调整费用 比较(notcontains)
   */
  private java.math.BigDecimal adjustmentsNotcontains;
  /**
   * 调整费用 比较(startswith)
   */
  private java.math.BigDecimal adjustmentsStartswith;
  /**
   * 调整费用 比较(endswith)
   */
  private java.math.BigDecimal adjustmentsEndswith;
  /**
   * 调整费用 比较(isnull)
   */
  private Boolean adjustmentsIsnull;
  /**
   * 调整费用 比较(isnotnull)
   */
  private Boolean adjustmentsIsnotnull;

  /**
   * 平台其他费
   */
  private java.math.BigDecimal totalPlatformOtherFee;

  /**
   * 最小平台其他费
   */
  private java.math.BigDecimal totalPlatformOtherFeeMin;

  /**
   * 最大平台其他费
   */
  private java.math.BigDecimal totalPlatformOtherFeeMax;

  /**
   * 平台其他费 比较(eq)
   */
  private java.math.BigDecimal totalPlatformOtherFeeEq;
  /**
   * 平台其他费 比较(neq)
   */
  private java.math.BigDecimal totalPlatformOtherFeeNeq;
  /**
   * 平台其他费 比较(gt)
   */
  private java.math.BigDecimal totalPlatformOtherFeeGt;
  /**
   * 平台其他费 比较(gte)
   */
  private java.math.BigDecimal totalPlatformOtherFeeGte;
  /**
   * 平台其他费 比较(lt)
   */
  private java.math.BigDecimal totalPlatformOtherFeeLt;
  /**
   * 平台其他费 比较(lte)
   */
  private java.math.BigDecimal totalPlatformOtherFeeLte;
  /**
   * 平台其他费 比较(contains)
   */
  private java.math.BigDecimal totalPlatformOtherFeeContains;
  /**
   * 平台其他费 比较(notcontains)
   */
  private java.math.BigDecimal totalPlatformOtherFeeNotcontains;
  /**
   * 平台其他费 比较(startswith)
   */
  private java.math.BigDecimal totalPlatformOtherFeeStartswith;
  /**
   * 平台其他费 比较(endswith)
   */
  private java.math.BigDecimal totalPlatformOtherFeeEndswith;
  /**
   * 平台其他费 比较(isnull)
   */
  private Boolean totalPlatformOtherFeeIsnull;
  /**
   * 平台其他费 比较(isnotnull)
   */
  private Boolean totalPlatformOtherFeeIsnotnull;

  /**
   * 运输标签费
   */
  private java.math.BigDecimal shippingLabelPurchases;

  /**
   * 最小运输标签费
   */
  private java.math.BigDecimal shippingLabelPurchasesMin;

  /**
   * 最大运输标签费
   */
  private java.math.BigDecimal shippingLabelPurchasesMax;

  /**
   * 运输标签费 比较(eq)
   */
  private java.math.BigDecimal shippingLabelPurchasesEq;
  /**
   * 运输标签费 比较(neq)
   */
  private java.math.BigDecimal shippingLabelPurchasesNeq;
  /**
   * 运输标签费 比较(gt)
   */
  private java.math.BigDecimal shippingLabelPurchasesGt;
  /**
   * 运输标签费 比较(gte)
   */
  private java.math.BigDecimal shippingLabelPurchasesGte;
  /**
   * 运输标签费 比较(lt)
   */
  private java.math.BigDecimal shippingLabelPurchasesLt;
  /**
   * 运输标签费 比较(lte)
   */
  private java.math.BigDecimal shippingLabelPurchasesLte;
  /**
   * 运输标签费 比较(contains)
   */
  private java.math.BigDecimal shippingLabelPurchasesContains;
  /**
   * 运输标签费 比较(notcontains)
   */
  private java.math.BigDecimal shippingLabelPurchasesNotcontains;
  /**
   * 运输标签费 比较(startswith)
   */
  private java.math.BigDecimal shippingLabelPurchasesStartswith;
  /**
   * 运输标签费 比较(endswith)
   */
  private java.math.BigDecimal shippingLabelPurchasesEndswith;
  /**
   * 运输标签费 比较(isnull)
   */
  private Boolean shippingLabelPurchasesIsnull;
  /**
   * 运输标签费 比较(isnotnull)
   */
  private Boolean shippingLabelPurchasesIsnotnull;

  /**
   * 承运人装运标签调整费
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustments;

  /**
   * 最小承运人装运标签调整费
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsMin;

  /**
   * 最大承运人装运标签调整费
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsMax;

  /**
   * 承运人装运标签调整费 比较(eq)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsEq;
  /**
   * 承运人装运标签调整费 比较(neq)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsNeq;
  /**
   * 承运人装运标签调整费 比较(gt)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsGt;
  /**
   * 承运人装运标签调整费 比较(gte)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsGte;
  /**
   * 承运人装运标签调整费 比较(lt)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsLt;
  /**
   * 承运人装运标签调整费 比较(lte)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsLte;
  /**
   * 承运人装运标签调整费 比较(contains)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsContains;
  /**
   * 承运人装运标签调整费 比较(notcontains)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsNotcontains;
  /**
   * 承运人装运标签调整费 比较(startswith)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsStartswith;
  /**
   * 承运人装运标签调整费 比较(endswith)
   */
  private java.math.BigDecimal sharedCarrierShippingLabelAdjustmentsEndswith;
  /**
   * 承运人装运标签调整费 比较(isnull)
   */
  private Boolean sharedCarrierShippingLabelAdjustmentsIsnull;
  /**
   * 承运人装运标签调整费 比较(isnotnull)
   */
  private Boolean sharedCarrierShippingLabelAdjustmentsIsnotnull;

  /**
   * 清算费
   */
  private java.math.BigDecimal sharedLiquidationsFees;

  /**
   * 最小清算费
   */
  private java.math.BigDecimal sharedLiquidationsFeesMin;

  /**
   * 最大清算费
   */
  private java.math.BigDecimal sharedLiquidationsFeesMax;

  /**
   * 清算费 比较(eq)
   */
  private java.math.BigDecimal sharedLiquidationsFeesEq;
  /**
   * 清算费 比较(neq)
   */
  private java.math.BigDecimal sharedLiquidationsFeesNeq;
  /**
   * 清算费 比较(gt)
   */
  private java.math.BigDecimal sharedLiquidationsFeesGt;
  /**
   * 清算费 比较(gte)
   */
  private java.math.BigDecimal sharedLiquidationsFeesGte;
  /**
   * 清算费 比较(lt)
   */
  private java.math.BigDecimal sharedLiquidationsFeesLt;
  /**
   * 清算费 比较(lte)
   */
  private java.math.BigDecimal sharedLiquidationsFeesLte;
  /**
   * 清算费 比较(contains)
   */
  private java.math.BigDecimal sharedLiquidationsFeesContains;
  /**
   * 清算费 比较(notcontains)
   */
  private java.math.BigDecimal sharedLiquidationsFeesNotcontains;
  /**
   * 清算费 比较(startswith)
   */
  private java.math.BigDecimal sharedLiquidationsFeesStartswith;
  /**
   * 清算费 比较(endswith)
   */
  private java.math.BigDecimal sharedLiquidationsFeesEndswith;
  /**
   * 清算费 比较(isnull)
   */
  private Boolean sharedLiquidationsFeesIsnull;
  /**
   * 清算费 比较(isnotnull)
   */
  private Boolean sharedLiquidationsFeesIsnotnull;

  /**
   * 人工处理费用
   */
  private java.math.BigDecimal sharedManualProcessingFee;

  /**
   * 最小人工处理费用
   */
  private java.math.BigDecimal sharedManualProcessingFeeMin;

  /**
   * 最大人工处理费用
   */
  private java.math.BigDecimal sharedManualProcessingFeeMax;

  /**
   * 人工处理费用 比较(eq)
   */
  private java.math.BigDecimal sharedManualProcessingFeeEq;
  /**
   * 人工处理费用 比较(neq)
   */
  private java.math.BigDecimal sharedManualProcessingFeeNeq;
  /**
   * 人工处理费用 比较(gt)
   */
  private java.math.BigDecimal sharedManualProcessingFeeGt;
  /**
   * 人工处理费用 比较(gte)
   */
  private java.math.BigDecimal sharedManualProcessingFeeGte;
  /**
   * 人工处理费用 比较(lt)
   */
  private java.math.BigDecimal sharedManualProcessingFeeLt;
  /**
   * 人工处理费用 比较(lte)
   */
  private java.math.BigDecimal sharedManualProcessingFeeLte;
  /**
   * 人工处理费用 比较(contains)
   */
  private java.math.BigDecimal sharedManualProcessingFeeContains;
  /**
   * 人工处理费用 比较(notcontains)
   */
  private java.math.BigDecimal sharedManualProcessingFeeNotcontains;
  /**
   * 人工处理费用 比较(startswith)
   */
  private java.math.BigDecimal sharedManualProcessingFeeStartswith;
  /**
   * 人工处理费用 比较(endswith)
   */
  private java.math.BigDecimal sharedManualProcessingFeeEndswith;
  /**
   * 人工处理费用 比较(isnull)
   */
  private Boolean sharedManualProcessingFeeIsnull;
  /**
   * 人工处理费用 比较(isnotnull)
   */
  private Boolean sharedManualProcessingFeeIsnotnull;

  /**
   * 其他服务费
   */
  private java.math.BigDecimal sharedOtherServiceFees;

  /**
   * 最小其他服务费
   */
  private java.math.BigDecimal sharedOtherServiceFeesMin;

  /**
   * 最大其他服务费
   */
  private java.math.BigDecimal sharedOtherServiceFeesMax;

  /**
   * 其他服务费 比较(eq)
   */
  private java.math.BigDecimal sharedOtherServiceFeesEq;
  /**
   * 其他服务费 比较(neq)
   */
  private java.math.BigDecimal sharedOtherServiceFeesNeq;
  /**
   * 其他服务费 比较(gt)
   */
  private java.math.BigDecimal sharedOtherServiceFeesGt;
  /**
   * 其他服务费 比较(gte)
   */
  private java.math.BigDecimal sharedOtherServiceFeesGte;
  /**
   * 其他服务费 比较(lt)
   */
  private java.math.BigDecimal sharedOtherServiceFeesLt;
  /**
   * 其他服务费 比较(lte)
   */
  private java.math.BigDecimal sharedOtherServiceFeesLte;
  /**
   * 其他服务费 比较(contains)
   */
  private java.math.BigDecimal sharedOtherServiceFeesContains;
  /**
   * 其他服务费 比较(notcontains)
   */
  private java.math.BigDecimal sharedOtherServiceFeesNotcontains;
  /**
   * 其他服务费 比较(startswith)
   */
  private java.math.BigDecimal sharedOtherServiceFeesStartswith;
  /**
   * 其他服务费 比较(endswith)
   */
  private java.math.BigDecimal sharedOtherServiceFeesEndswith;
  /**
   * 其他服务费 比较(isnull)
   */
  private Boolean sharedOtherServiceFeesIsnull;
  /**
   * 其他服务费 比较(isnotnull)
   */
  private Boolean sharedOtherServiceFeesIsnotnull;

  /**
   * 销售税
   */
  private java.math.BigDecimal totalSalesTax;

  /**
   * 最小销售税
   */
  private java.math.BigDecimal totalSalesTaxMin;

  /**
   * 最大销售税
   */
  private java.math.BigDecimal totalSalesTaxMax;

  /**
   * 销售税 比较(eq)
   */
  private java.math.BigDecimal totalSalesTaxEq;
  /**
   * 销售税 比较(neq)
   */
  private java.math.BigDecimal totalSalesTaxNeq;
  /**
   * 销售税 比较(gt)
   */
  private java.math.BigDecimal totalSalesTaxGt;
  /**
   * 销售税 比较(gte)
   */
  private java.math.BigDecimal totalSalesTaxGte;
  /**
   * 销售税 比较(lt)
   */
  private java.math.BigDecimal totalSalesTaxLt;
  /**
   * 销售税 比较(lte)
   */
  private java.math.BigDecimal totalSalesTaxLte;
  /**
   * 销售税 比较(contains)
   */
  private java.math.BigDecimal totalSalesTaxContains;
  /**
   * 销售税 比较(notcontains)
   */
  private java.math.BigDecimal totalSalesTaxNotcontains;
  /**
   * 销售税 比较(startswith)
   */
  private java.math.BigDecimal totalSalesTaxStartswith;
  /**
   * 销售税 比较(endswith)
   */
  private java.math.BigDecimal totalSalesTaxEndswith;
  /**
   * 销售税 比较(isnull)
   */
  private Boolean totalSalesTaxIsnull;
  /**
   * 销售税 比较(isnotnull)
   */
  private Boolean totalSalesTaxIsnotnull;

  /**
   * VAT/GST
   */
  private java.math.BigDecimal taxCollected;

  /**
   * 最小VAT/GST
   */
  private java.math.BigDecimal taxCollectedMin;

  /**
   * 最大VAT/GST
   */
  private java.math.BigDecimal taxCollectedMax;

  /**
   * VAT/GST 比较(eq)
   */
  private java.math.BigDecimal taxCollectedEq;
  /**
   * VAT/GST 比较(neq)
   */
  private java.math.BigDecimal taxCollectedNeq;
  /**
   * VAT/GST 比较(gt)
   */
  private java.math.BigDecimal taxCollectedGt;
  /**
   * VAT/GST 比较(gte)
   */
  private java.math.BigDecimal taxCollectedGte;
  /**
   * VAT/GST 比较(lt)
   */
  private java.math.BigDecimal taxCollectedLt;
  /**
   * VAT/GST 比较(lte)
   */
  private java.math.BigDecimal taxCollectedLte;
  /**
   * VAT/GST 比较(contains)
   */
  private java.math.BigDecimal taxCollectedContains;
  /**
   * VAT/GST 比较(notcontains)
   */
  private java.math.BigDecimal taxCollectedNotcontains;
  /**
   * VAT/GST 比较(startswith)
   */
  private java.math.BigDecimal taxCollectedStartswith;
  /**
   * VAT/GST 比较(endswith)
   */
  private java.math.BigDecimal taxCollectedEndswith;
  /**
   * VAT/GST 比较(isnull)
   */
  private Boolean taxCollectedIsnull;
  /**
   * VAT/GST 比较(isnotnull)
   */
  private Boolean taxCollectedIsnotnull;

  /**
   * TCS-IGST
   */
  private java.math.BigDecimal tcsIgstCollected;

  /**
   * 最小TCS-IGST
   */
  private java.math.BigDecimal tcsIgstCollectedMin;

  /**
   * 最大TCS-IGST
   */
  private java.math.BigDecimal tcsIgstCollectedMax;

  /**
   * TCS-IGST 比较(eq)
   */
  private java.math.BigDecimal tcsIgstCollectedEq;
  /**
   * TCS-IGST 比较(neq)
   */
  private java.math.BigDecimal tcsIgstCollectedNeq;
  /**
   * TCS-IGST 比较(gt)
   */
  private java.math.BigDecimal tcsIgstCollectedGt;
  /**
   * TCS-IGST 比较(gte)
   */
  private java.math.BigDecimal tcsIgstCollectedGte;
  /**
   * TCS-IGST 比较(lt)
   */
  private java.math.BigDecimal tcsIgstCollectedLt;
  /**
   * TCS-IGST 比较(lte)
   */
  private java.math.BigDecimal tcsIgstCollectedLte;
  /**
   * TCS-IGST 比较(contains)
   */
  private java.math.BigDecimal tcsIgstCollectedContains;
  /**
   * TCS-IGST 比较(notcontains)
   */
  private java.math.BigDecimal tcsIgstCollectedNotcontains;
  /**
   * TCS-IGST 比较(startswith)
   */
  private java.math.BigDecimal tcsIgstCollectedStartswith;
  /**
   * TCS-IGST 比较(endswith)
   */
  private java.math.BigDecimal tcsIgstCollectedEndswith;
  /**
   * TCS-IGST 比较(isnull)
   */
  private Boolean tcsIgstCollectedIsnull;
  /**
   * TCS-IGST 比较(isnotnull)
   */
  private Boolean tcsIgstCollectedIsnotnull;

  /**
   * TCS-SGST
   */
  private java.math.BigDecimal tcsSgstCollected;

  /**
   * 最小TCS-SGST
   */
  private java.math.BigDecimal tcsSgstCollectedMin;

  /**
   * 最大TCS-SGST
   */
  private java.math.BigDecimal tcsSgstCollectedMax;

  /**
   * TCS-SGST 比较(eq)
   */
  private java.math.BigDecimal tcsSgstCollectedEq;
  /**
   * TCS-SGST 比较(neq)
   */
  private java.math.BigDecimal tcsSgstCollectedNeq;
  /**
   * TCS-SGST 比较(gt)
   */
  private java.math.BigDecimal tcsSgstCollectedGt;
  /**
   * TCS-SGST 比较(gte)
   */
  private java.math.BigDecimal tcsSgstCollectedGte;
  /**
   * TCS-SGST 比较(lt)
   */
  private java.math.BigDecimal tcsSgstCollectedLt;
  /**
   * TCS-SGST 比较(lte)
   */
  private java.math.BigDecimal tcsSgstCollectedLte;
  /**
   * TCS-SGST 比较(contains)
   */
  private java.math.BigDecimal tcsSgstCollectedContains;
  /**
   * TCS-SGST 比较(notcontains)
   */
  private java.math.BigDecimal tcsSgstCollectedNotcontains;
  /**
   * TCS-SGST 比较(startswith)
   */
  private java.math.BigDecimal tcsSgstCollectedStartswith;
  /**
   * TCS-SGST 比较(endswith)
   */
  private java.math.BigDecimal tcsSgstCollectedEndswith;
  /**
   * TCS-SGST 比较(isnull)
   */
  private Boolean tcsSgstCollectedIsnull;
  /**
   * TCS-SGST 比较(isnotnull)
   */
  private Boolean tcsSgstCollectedIsnotnull;

  /**
   * TCS-CGST
   */
  private java.math.BigDecimal tcsCgstCollected;

  /**
   * 最小TCS-CGST
   */
  private java.math.BigDecimal tcsCgstCollectedMin;

  /**
   * 最大TCS-CGST
   */
  private java.math.BigDecimal tcsCgstCollectedMax;

  /**
   * TCS-CGST 比较(eq)
   */
  private java.math.BigDecimal tcsCgstCollectedEq;
  /**
   * TCS-CGST 比较(neq)
   */
  private java.math.BigDecimal tcsCgstCollectedNeq;
  /**
   * TCS-CGST 比较(gt)
   */
  private java.math.BigDecimal tcsCgstCollectedGt;
  /**
   * TCS-CGST 比较(gte)
   */
  private java.math.BigDecimal tcsCgstCollectedGte;
  /**
   * TCS-CGST 比较(lt)
   */
  private java.math.BigDecimal tcsCgstCollectedLt;
  /**
   * TCS-CGST 比较(lte)
   */
  private java.math.BigDecimal tcsCgstCollectedLte;
  /**
   * TCS-CGST 比较(contains)
   */
  private java.math.BigDecimal tcsCgstCollectedContains;
  /**
   * TCS-CGST 比较(notcontains)
   */
  private java.math.BigDecimal tcsCgstCollectedNotcontains;
  /**
   * TCS-CGST 比较(startswith)
   */
  private java.math.BigDecimal tcsCgstCollectedStartswith;
  /**
   * TCS-CGST 比较(endswith)
   */
  private java.math.BigDecimal tcsCgstCollectedEndswith;
  /**
   * TCS-CGST 比较(isnull)
   */
  private Boolean tcsCgstCollectedIsnull;
  /**
   * TCS-CGST 比较(isnotnull)
   */
  private Boolean tcsCgstCollectedIsnotnull;

  /**
   * 混合VAT
   */
  private java.math.BigDecimal sharedComminglingVatExpenses;

  /**
   * 最小混合VAT
   */
  private java.math.BigDecimal sharedComminglingVatExpensesMin;

  /**
   * 最大混合VAT
   */
  private java.math.BigDecimal sharedComminglingVatExpensesMax;

  /**
   * 混合VAT 比较(eq)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesEq;
  /**
   * 混合VAT 比较(neq)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesNeq;
  /**
   * 混合VAT 比较(gt)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesGt;
  /**
   * 混合VAT 比较(gte)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesGte;
  /**
   * 混合VAT 比较(lt)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesLt;
  /**
   * 混合VAT 比较(lte)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesLte;
  /**
   * 混合VAT 比较(contains)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesContains;
  /**
   * 混合VAT 比较(notcontains)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesNotcontains;
  /**
   * 混合VAT 比较(startswith)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesStartswith;
  /**
   * 混合VAT 比较(endswith)
   */
  private java.math.BigDecimal sharedComminglingVatExpensesEndswith;
  /**
   * 混合VAT 比较(isnull)
   */
  private Boolean sharedComminglingVatExpensesIsnull;
  /**
   * 混合VAT 比较(isnotnull)
   */
  private Boolean sharedComminglingVatExpensesIsnotnull;

  /**
   * 销售税退款额
   */
  private java.math.BigDecimal salesTaxRefund;

  /**
   * 最小销售税退款额
   */
  private java.math.BigDecimal salesTaxRefundMin;

  /**
   * 最大销售税退款额
   */
  private java.math.BigDecimal salesTaxRefundMax;

  /**
   * 销售税退款额 比较(eq)
   */
  private java.math.BigDecimal salesTaxRefundEq;
  /**
   * 销售税退款额 比较(neq)
   */
  private java.math.BigDecimal salesTaxRefundNeq;
  /**
   * 销售税退款额 比较(gt)
   */
  private java.math.BigDecimal salesTaxRefundGt;
  /**
   * 销售税退款额 比较(gte)
   */
  private java.math.BigDecimal salesTaxRefundGte;
  /**
   * 销售税退款额 比较(lt)
   */
  private java.math.BigDecimal salesTaxRefundLt;
  /**
   * 销售税退款额 比较(lte)
   */
  private java.math.BigDecimal salesTaxRefundLte;
  /**
   * 销售税退款额 比较(contains)
   */
  private java.math.BigDecimal salesTaxRefundContains;
  /**
   * 销售税退款额 比较(notcontains)
   */
  private java.math.BigDecimal salesTaxRefundNotcontains;
  /**
   * 销售税退款额 比较(startswith)
   */
  private java.math.BigDecimal salesTaxRefundStartswith;
  /**
   * 销售税退款额 比较(endswith)
   */
  private java.math.BigDecimal salesTaxRefundEndswith;
  /**
   * 销售税退款额 比较(isnull)
   */
  private Boolean salesTaxRefundIsnull;
  /**
   * 销售税退款额 比较(isnotnull)
   */
  private Boolean salesTaxRefundIsnotnull;

  /**
   * VAT/GST
   */
  private java.math.BigDecimal taxRefunded;

  /**
   * 最小VAT/GST
   */
  private java.math.BigDecimal taxRefundedMin;

  /**
   * 最大VAT/GST
   */
  private java.math.BigDecimal taxRefundedMax;

  /**
   * VAT/GST 比较(eq)
   */
  private java.math.BigDecimal taxRefundedEq;
  /**
   * VAT/GST 比较(neq)
   */
  private java.math.BigDecimal taxRefundedNeq;
  /**
   * VAT/GST 比较(gt)
   */
  private java.math.BigDecimal taxRefundedGt;
  /**
   * VAT/GST 比较(gte)
   */
  private java.math.BigDecimal taxRefundedGte;
  /**
   * VAT/GST 比较(lt)
   */
  private java.math.BigDecimal taxRefundedLt;
  /**
   * VAT/GST 比较(lte)
   */
  private java.math.BigDecimal taxRefundedLte;
  /**
   * VAT/GST 比较(contains)
   */
  private java.math.BigDecimal taxRefundedContains;
  /**
   * VAT/GST 比较(notcontains)
   */
  private java.math.BigDecimal taxRefundedNotcontains;
  /**
   * VAT/GST 比较(startswith)
   */
  private java.math.BigDecimal taxRefundedStartswith;
  /**
   * VAT/GST 比较(endswith)
   */
  private java.math.BigDecimal taxRefundedEndswith;
  /**
   * VAT/GST 比较(isnull)
   */
  private Boolean taxRefundedIsnull;
  /**
   * VAT/GST 比较(isnotnull)
   */
  private Boolean taxRefundedIsnotnull;

  /**
   * TCS-IGST
   */
  private java.math.BigDecimal tcsIgstRefunded;

  /**
   * 最小TCS-IGST
   */
  private java.math.BigDecimal tcsIgstRefundedMin;

  /**
   * 最大TCS-IGST
   */
  private java.math.BigDecimal tcsIgstRefundedMax;

  /**
   * TCS-IGST 比较(eq)
   */
  private java.math.BigDecimal tcsIgstRefundedEq;
  /**
   * TCS-IGST 比较(neq)
   */
  private java.math.BigDecimal tcsIgstRefundedNeq;
  /**
   * TCS-IGST 比较(gt)
   */
  private java.math.BigDecimal tcsIgstRefundedGt;
  /**
   * TCS-IGST 比较(gte)
   */
  private java.math.BigDecimal tcsIgstRefundedGte;
  /**
   * TCS-IGST 比较(lt)
   */
  private java.math.BigDecimal tcsIgstRefundedLt;
  /**
   * TCS-IGST 比较(lte)
   */
  private java.math.BigDecimal tcsIgstRefundedLte;
  /**
   * TCS-IGST 比较(contains)
   */
  private java.math.BigDecimal tcsIgstRefundedContains;
  /**
   * TCS-IGST 比较(notcontains)
   */
  private java.math.BigDecimal tcsIgstRefundedNotcontains;
  /**
   * TCS-IGST 比较(startswith)
   */
  private java.math.BigDecimal tcsIgstRefundedStartswith;
  /**
   * TCS-IGST 比较(endswith)
   */
  private java.math.BigDecimal tcsIgstRefundedEndswith;
  /**
   * TCS-IGST 比较(isnull)
   */
  private Boolean tcsIgstRefundedIsnull;
  /**
   * TCS-IGST 比较(isnotnull)
   */
  private Boolean tcsIgstRefundedIsnotnull;

  /**
   * TCS-SGST
   */
  private java.math.BigDecimal tcsSgstRefunded;

  /**
   * 最小TCS-SGST
   */
  private java.math.BigDecimal tcsSgstRefundedMin;

  /**
   * 最大TCS-SGST
   */
  private java.math.BigDecimal tcsSgstRefundedMax;

  /**
   * TCS-SGST 比较(eq)
   */
  private java.math.BigDecimal tcsSgstRefundedEq;
  /**
   * TCS-SGST 比较(neq)
   */
  private java.math.BigDecimal tcsSgstRefundedNeq;
  /**
   * TCS-SGST 比较(gt)
   */
  private java.math.BigDecimal tcsSgstRefundedGt;
  /**
   * TCS-SGST 比较(gte)
   */
  private java.math.BigDecimal tcsSgstRefundedGte;
  /**
   * TCS-SGST 比较(lt)
   */
  private java.math.BigDecimal tcsSgstRefundedLt;
  /**
   * TCS-SGST 比较(lte)
   */
  private java.math.BigDecimal tcsSgstRefundedLte;
  /**
   * TCS-SGST 比较(contains)
   */
  private java.math.BigDecimal tcsSgstRefundedContains;
  /**
   * TCS-SGST 比较(notcontains)
   */
  private java.math.BigDecimal tcsSgstRefundedNotcontains;
  /**
   * TCS-SGST 比较(startswith)
   */
  private java.math.BigDecimal tcsSgstRefundedStartswith;
  /**
   * TCS-SGST 比较(endswith)
   */
  private java.math.BigDecimal tcsSgstRefundedEndswith;
  /**
   * TCS-SGST 比较(isnull)
   */
  private Boolean tcsSgstRefundedIsnull;
  /**
   * TCS-SGST 比较(isnotnull)
   */
  private Boolean tcsSgstRefundedIsnotnull;

  /**
   * TCS-CGST
   */
  private java.math.BigDecimal tcsCgstRefunded;

  /**
   * 最小TCS-CGST
   */
  private java.math.BigDecimal tcsCgstRefundedMin;

  /**
   * 最大TCS-CGST
   */
  private java.math.BigDecimal tcsCgstRefundedMax;

  /**
   * TCS-CGST 比较(eq)
   */
  private java.math.BigDecimal tcsCgstRefundedEq;
  /**
   * TCS-CGST 比较(neq)
   */
  private java.math.BigDecimal tcsCgstRefundedNeq;
  /**
   * TCS-CGST 比较(gt)
   */
  private java.math.BigDecimal tcsCgstRefundedGt;
  /**
   * TCS-CGST 比较(gte)
   */
  private java.math.BigDecimal tcsCgstRefundedGte;
  /**
   * TCS-CGST 比较(lt)
   */
  private java.math.BigDecimal tcsCgstRefundedLt;
  /**
   * TCS-CGST 比较(lte)
   */
  private java.math.BigDecimal tcsCgstRefundedLte;
  /**
   * TCS-CGST 比较(contains)
   */
  private java.math.BigDecimal tcsCgstRefundedContains;
  /**
   * TCS-CGST 比较(notcontains)
   */
  private java.math.BigDecimal tcsCgstRefundedNotcontains;
  /**
   * TCS-CGST 比较(startswith)
   */
  private java.math.BigDecimal tcsCgstRefundedStartswith;
  /**
   * TCS-CGST 比较(endswith)
   */
  private java.math.BigDecimal tcsCgstRefundedEndswith;
  /**
   * TCS-CGST 比较(isnull)
   */
  private Boolean tcsCgstRefundedIsnull;
  /**
   * TCS-CGST 比较(isnotnull)
   */
  private Boolean tcsCgstRefundedIsnotnull;

  /**
   * 市场税
   */
  private java.math.BigDecimal salesTaxWithheld;

  /**
   * 最小市场税
   */
  private java.math.BigDecimal salesTaxWithheldMin;

  /**
   * 最大市场税
   */
  private java.math.BigDecimal salesTaxWithheldMax;

  /**
   * 市场税 比较(eq)
   */
  private java.math.BigDecimal salesTaxWithheldEq;
  /**
   * 市场税 比较(neq)
   */
  private java.math.BigDecimal salesTaxWithheldNeq;
  /**
   * 市场税 比较(gt)
   */
  private java.math.BigDecimal salesTaxWithheldGt;
  /**
   * 市场税 比较(gte)
   */
  private java.math.BigDecimal salesTaxWithheldGte;
  /**
   * 市场税 比较(lt)
   */
  private java.math.BigDecimal salesTaxWithheldLt;
  /**
   * 市场税 比较(lte)
   */
  private java.math.BigDecimal salesTaxWithheldLte;
  /**
   * 市场税 比较(contains)
   */
  private java.math.BigDecimal salesTaxWithheldContains;
  /**
   * 市场税 比较(notcontains)
   */
  private java.math.BigDecimal salesTaxWithheldNotcontains;
  /**
   * 市场税 比较(startswith)
   */
  private java.math.BigDecimal salesTaxWithheldStartswith;
  /**
   * 市场税 比较(endswith)
   */
  private java.math.BigDecimal salesTaxWithheldEndswith;
  /**
   * 市场税 比较(isnull)
   */
  private Boolean salesTaxWithheldIsnull;
  /**
   * 市场税 比较(isnotnull)
   */
  private Boolean salesTaxWithheldIsnotnull;

  /**
   * 市场税退款额
   */
  private java.math.BigDecimal refundTaxWithheld;

  /**
   * 最小市场税退款额
   */
  private java.math.BigDecimal refundTaxWithheldMin;

  /**
   * 最大市场税退款额
   */
  private java.math.BigDecimal refundTaxWithheldMax;

  /**
   * 市场税退款额 比较(eq)
   */
  private java.math.BigDecimal refundTaxWithheldEq;
  /**
   * 市场税退款额 比较(neq)
   */
  private java.math.BigDecimal refundTaxWithheldNeq;
  /**
   * 市场税退款额 比较(gt)
   */
  private java.math.BigDecimal refundTaxWithheldGt;
  /**
   * 市场税退款额 比较(gte)
   */
  private java.math.BigDecimal refundTaxWithheldGte;
  /**
   * 市场税退款额 比较(lt)
   */
  private java.math.BigDecimal refundTaxWithheldLt;
  /**
   * 市场税退款额 比较(lte)
   */
  private java.math.BigDecimal refundTaxWithheldLte;
  /**
   * 市场税退款额 比较(contains)
   */
  private java.math.BigDecimal refundTaxWithheldContains;
  /**
   * 市场税退款额 比较(notcontains)
   */
  private java.math.BigDecimal refundTaxWithheldNotcontains;
  /**
   * 市场税退款额 比较(startswith)
   */
  private java.math.BigDecimal refundTaxWithheldStartswith;
  /**
   * 市场税退款额 比较(endswith)
   */
  private java.math.BigDecimal refundTaxWithheldEndswith;
  /**
   * 市场税退款额 比较(isnull)
   */
  private Boolean refundTaxWithheldIsnull;
  /**
   * 市场税退款额 比较(isnotnull)
   */
  private Boolean refundTaxWithheldIsnotnull;

  /**
   * 混合网路费用
   */
  private java.math.BigDecimal tdsSection194ONet;

  /**
   * 最小混合网路费用
   */
  private java.math.BigDecimal tdsSection194ONetMin;

  /**
   * 最大混合网路费用
   */
  private java.math.BigDecimal tdsSection194ONetMax;

  /**
   * 混合网路费用 比较(eq)
   */
  private java.math.BigDecimal tdsSection194ONetEq;
  /**
   * 混合网路费用 比较(neq)
   */
  private java.math.BigDecimal tdsSection194ONetNeq;
  /**
   * 混合网路费用 比较(gt)
   */
  private java.math.BigDecimal tdsSection194ONetGt;
  /**
   * 混合网路费用 比较(gte)
   */
  private java.math.BigDecimal tdsSection194ONetGte;
  /**
   * 混合网路费用 比较(lt)
   */
  private java.math.BigDecimal tdsSection194ONetLt;
  /**
   * 混合网路费用 比较(lte)
   */
  private java.math.BigDecimal tdsSection194ONetLte;
  /**
   * 混合网路费用 比较(contains)
   */
  private java.math.BigDecimal tdsSection194ONetContains;
  /**
   * 混合网路费用 比较(notcontains)
   */
  private java.math.BigDecimal tdsSection194ONetNotcontains;
  /**
   * 混合网路费用 比较(startswith)
   */
  private java.math.BigDecimal tdsSection194ONetStartswith;
  /**
   * 混合网路费用 比较(endswith)
   */
  private java.math.BigDecimal tdsSection194ONetEndswith;
  /**
   * 混合网路费用 比较(isnull)
   */
  private Boolean tdsSection194ONetIsnull;
  /**
   * 混合网路费用 比较(isnotnull)
   */
  private Boolean tdsSection194ONetIsnotnull;

  /**
   * 采购成本
   */
  private java.math.BigDecimal cgPriceTotal;

  /**
   * 最小采购成本
   */
  private java.math.BigDecimal cgPriceTotalMin;

  /**
   * 最大采购成本
   */
  private java.math.BigDecimal cgPriceTotalMax;

  /**
   * 采购成本 比较(eq)
   */
  private java.math.BigDecimal cgPriceTotalEq;
  /**
   * 采购成本 比较(neq)
   */
  private java.math.BigDecimal cgPriceTotalNeq;
  /**
   * 采购成本 比较(gt)
   */
  private java.math.BigDecimal cgPriceTotalGt;
  /**
   * 采购成本 比较(gte)
   */
  private java.math.BigDecimal cgPriceTotalGte;
  /**
   * 采购成本 比较(lt)
   */
  private java.math.BigDecimal cgPriceTotalLt;
  /**
   * 采购成本 比较(lte)
   */
  private java.math.BigDecimal cgPriceTotalLte;
  /**
   * 采购成本 比较(contains)
   */
  private java.math.BigDecimal cgPriceTotalContains;
  /**
   * 采购成本 比较(notcontains)
   */
  private java.math.BigDecimal cgPriceTotalNotcontains;
  /**
   * 采购成本 比较(startswith)
   */
  private java.math.BigDecimal cgPriceTotalStartswith;
  /**
   * 采购成本 比较(endswith)
   */
  private java.math.BigDecimal cgPriceTotalEndswith;
  /**
   * 采购成本 比较(isnull)
   */
  private Boolean cgPriceTotalIsnull;
  /**
   * 采购成本 比较(isnotnull)
   */
  private Boolean cgPriceTotalIsnotnull;

  /**
   * 是否有采购成本明细
   */
  private Integer hasCgPriceDetail;

  /**
   * 最小是否有采购成本明细
   */
  private Integer hasCgPriceDetailMin;

  /**
   * 最大是否有采购成本明细
   */
  private Integer hasCgPriceDetailMax;

  /**
   * 是否有采购成本明细 比较(eq)
   */
  private Integer hasCgPriceDetailEq;
  /**
   * 是否有采购成本明细 比较(neq)
   */
  private Integer hasCgPriceDetailNeq;
  /**
   * 是否有采购成本明细 比较(gt)
   */
  private Integer hasCgPriceDetailGt;
  /**
   * 是否有采购成本明细 比较(gte)
   */
  private Integer hasCgPriceDetailGte;
  /**
   * 是否有采购成本明细 比较(lt)
   */
  private Integer hasCgPriceDetailLt;
  /**
   * 是否有采购成本明细 比较(lte)
   */
  private Integer hasCgPriceDetailLte;
  /**
   * 是否有采购成本明细 比较(contains)
   */
  private Integer hasCgPriceDetailContains;
  /**
   * 是否有采购成本明细 比较(notcontains)
   */
  private Integer hasCgPriceDetailNotcontains;
  /**
   * 是否有采购成本明细 比较(startswith)
   */
  private Integer hasCgPriceDetailStartswith;
  /**
   * 是否有采购成本明细 比较(endswith)
   */
  private Integer hasCgPriceDetailEndswith;
  /**
   * 是否有采购成本明细 比较(isnull)
   */
  private Boolean hasCgPriceDetailIsnull;
  /**
   * 是否有采购成本明细 比较(isnotnull)
   */
  private Boolean hasCgPriceDetailIsnotnull;

  /**
   * 采购单价
   */
  private java.math.BigDecimal cgUnitPrice;

  /**
   * 最小采购单价
   */
  private java.math.BigDecimal cgUnitPriceMin;

  /**
   * 最大采购单价
   */
  private java.math.BigDecimal cgUnitPriceMax;

  /**
   * 采购单价 比较(eq)
   */
  private java.math.BigDecimal cgUnitPriceEq;
  /**
   * 采购单价 比较(neq)
   */
  private java.math.BigDecimal cgUnitPriceNeq;
  /**
   * 采购单价 比较(gt)
   */
  private java.math.BigDecimal cgUnitPriceGt;
  /**
   * 采购单价 比较(gte)
   */
  private java.math.BigDecimal cgUnitPriceGte;
  /**
   * 采购单价 比较(lt)
   */
  private java.math.BigDecimal cgUnitPriceLt;
  /**
   * 采购单价 比较(lte)
   */
  private java.math.BigDecimal cgUnitPriceLte;
  /**
   * 采购单价 比较(contains)
   */
  private java.math.BigDecimal cgUnitPriceContains;
  /**
   * 采购单价 比较(notcontains)
   */
  private java.math.BigDecimal cgUnitPriceNotcontains;
  /**
   * 采购单价 比较(startswith)
   */
  private java.math.BigDecimal cgUnitPriceStartswith;
  /**
   * 采购单价 比较(endswith)
   */
  private java.math.BigDecimal cgUnitPriceEndswith;
  /**
   * 采购单价 比较(isnull)
   */
  private Boolean cgUnitPriceIsnull;
  /**
   * 采购单价 比较(isnotnull)
   */
  private Boolean cgUnitPriceIsnotnull;

  /**
   * 采购占比
   */
  private java.math.BigDecimal proportionOfCg;

  /**
   * 最小采购占比
   */
  private java.math.BigDecimal proportionOfCgMin;

  /**
   * 最大采购占比
   */
  private java.math.BigDecimal proportionOfCgMax;

  /**
   * 采购占比 比较(eq)
   */
  private java.math.BigDecimal proportionOfCgEq;
  /**
   * 采购占比 比较(neq)
   */
  private java.math.BigDecimal proportionOfCgNeq;
  /**
   * 采购占比 比较(gt)
   */
  private java.math.BigDecimal proportionOfCgGt;
  /**
   * 采购占比 比较(gte)
   */
  private java.math.BigDecimal proportionOfCgGte;
  /**
   * 采购占比 比较(lt)
   */
  private java.math.BigDecimal proportionOfCgLt;
  /**
   * 采购占比 比较(lte)
   */
  private java.math.BigDecimal proportionOfCgLte;
  /**
   * 采购占比 比较(contains)
   */
  private java.math.BigDecimal proportionOfCgContains;
  /**
   * 采购占比 比较(notcontains)
   */
  private java.math.BigDecimal proportionOfCgNotcontains;
  /**
   * 采购占比 比较(startswith)
   */
  private java.math.BigDecimal proportionOfCgStartswith;
  /**
   * 采购占比 比较(endswith)
   */
  private java.math.BigDecimal proportionOfCgEndswith;
  /**
   * 采购占比 比较(isnull)
   */
  private Boolean proportionOfCgIsnull;
  /**
   * 采购占比 比较(isnotnull)
   */
  private Boolean proportionOfCgIsnotnull;

  /**
   * 头程成本
   */
  private java.math.BigDecimal cgTransportCostsTotal;

  /**
   * 最小头程成本
   */
  private java.math.BigDecimal cgTransportCostsTotalMin;

  /**
   * 最大头程成本
   */
  private java.math.BigDecimal cgTransportCostsTotalMax;

  /**
   * 头程成本 比较(eq)
   */
  private java.math.BigDecimal cgTransportCostsTotalEq;
  /**
   * 头程成本 比较(neq)
   */
  private java.math.BigDecimal cgTransportCostsTotalNeq;
  /**
   * 头程成本 比较(gt)
   */
  private java.math.BigDecimal cgTransportCostsTotalGt;
  /**
   * 头程成本 比较(gte)
   */
  private java.math.BigDecimal cgTransportCostsTotalGte;
  /**
   * 头程成本 比较(lt)
   */
  private java.math.BigDecimal cgTransportCostsTotalLt;
  /**
   * 头程成本 比较(lte)
   */
  private java.math.BigDecimal cgTransportCostsTotalLte;
  /**
   * 头程成本 比较(contains)
   */
  private java.math.BigDecimal cgTransportCostsTotalContains;
  /**
   * 头程成本 比较(notcontains)
   */
  private java.math.BigDecimal cgTransportCostsTotalNotcontains;
  /**
   * 头程成本 比较(startswith)
   */
  private java.math.BigDecimal cgTransportCostsTotalStartswith;
  /**
   * 头程成本 比较(endswith)
   */
  private java.math.BigDecimal cgTransportCostsTotalEndswith;
  /**
   * 头程成本 比较(isnull)
   */
  private Boolean cgTransportCostsTotalIsnull;
  /**
   * 头程成本 比较(isnotnull)
   */
  private Boolean cgTransportCostsTotalIsnotnull;

  /**
   * 是否有物流（头程）成本明细
   */
  private Integer hasCgTransportCostsDetail;

  /**
   * 最小是否有物流（头程）成本明细
   */
  private Integer hasCgTransportCostsDetailMin;

  /**
   * 最大是否有物流（头程）成本明细
   */
  private Integer hasCgTransportCostsDetailMax;

  /**
   * 是否有物流（头程）成本明细 比较(eq)
   */
  private Integer hasCgTransportCostsDetailEq;
  /**
   * 是否有物流（头程）成本明细 比较(neq)
   */
  private Integer hasCgTransportCostsDetailNeq;
  /**
   * 是否有物流（头程）成本明细 比较(gt)
   */
  private Integer hasCgTransportCostsDetailGt;
  /**
   * 是否有物流（头程）成本明细 比较(gte)
   */
  private Integer hasCgTransportCostsDetailGte;
  /**
   * 是否有物流（头程）成本明细 比较(lt)
   */
  private Integer hasCgTransportCostsDetailLt;
  /**
   * 是否有物流（头程）成本明细 比较(lte)
   */
  private Integer hasCgTransportCostsDetailLte;
  /**
   * 是否有物流（头程）成本明细 比较(contains)
   */
  private Integer hasCgTransportCostsDetailContains;
  /**
   * 是否有物流（头程）成本明细 比较(notcontains)
   */
  private Integer hasCgTransportCostsDetailNotcontains;
  /**
   * 是否有物流（头程）成本明细 比较(startswith)
   */
  private Integer hasCgTransportCostsDetailStartswith;
  /**
   * 是否有物流（头程）成本明细 比较(endswith)
   */
  private Integer hasCgTransportCostsDetailEndswith;
  /**
   * 是否有物流（头程）成本明细 比较(isnull)
   */
  private Boolean hasCgTransportCostsDetailIsnull;
  /**
   * 是否有物流（头程）成本明细 比较(isnotnull)
   */
  private Boolean hasCgTransportCostsDetailIsnotnull;

  /**
   * 头程单价
   */
  private java.math.BigDecimal cgTransportUnitCosts;

  /**
   * 最小头程单价
   */
  private java.math.BigDecimal cgTransportUnitCostsMin;

  /**
   * 最大头程单价
   */
  private java.math.BigDecimal cgTransportUnitCostsMax;

  /**
   * 头程单价 比较(eq)
   */
  private java.math.BigDecimal cgTransportUnitCostsEq;
  /**
   * 头程单价 比较(neq)
   */
  private java.math.BigDecimal cgTransportUnitCostsNeq;
  /**
   * 头程单价 比较(gt)
   */
  private java.math.BigDecimal cgTransportUnitCostsGt;
  /**
   * 头程单价 比较(gte)
   */
  private java.math.BigDecimal cgTransportUnitCostsGte;
  /**
   * 头程单价 比较(lt)
   */
  private java.math.BigDecimal cgTransportUnitCostsLt;
  /**
   * 头程单价 比较(lte)
   */
  private java.math.BigDecimal cgTransportUnitCostsLte;
  /**
   * 头程单价 比较(contains)
   */
  private java.math.BigDecimal cgTransportUnitCostsContains;
  /**
   * 头程单价 比较(notcontains)
   */
  private java.math.BigDecimal cgTransportUnitCostsNotcontains;
  /**
   * 头程单价 比较(startswith)
   */
  private java.math.BigDecimal cgTransportUnitCostsStartswith;
  /**
   * 头程单价 比较(endswith)
   */
  private java.math.BigDecimal cgTransportUnitCostsEndswith;
  /**
   * 头程单价 比较(isnull)
   */
  private Boolean cgTransportUnitCostsIsnull;
  /**
   * 头程单价 比较(isnotnull)
   */
  private Boolean cgTransportUnitCostsIsnotnull;

  /**
   * 头程占比
   */
  private java.math.BigDecimal proportionOfCgTransport;

  /**
   * 最小头程占比
   */
  private java.math.BigDecimal proportionOfCgTransportMin;

  /**
   * 最大头程占比
   */
  private java.math.BigDecimal proportionOfCgTransportMax;

  /**
   * 头程占比 比较(eq)
   */
  private java.math.BigDecimal proportionOfCgTransportEq;
  /**
   * 头程占比 比较(neq)
   */
  private java.math.BigDecimal proportionOfCgTransportNeq;
  /**
   * 头程占比 比较(gt)
   */
  private java.math.BigDecimal proportionOfCgTransportGt;
  /**
   * 头程占比 比较(gte)
   */
  private java.math.BigDecimal proportionOfCgTransportGte;
  /**
   * 头程占比 比较(lt)
   */
  private java.math.BigDecimal proportionOfCgTransportLt;
  /**
   * 头程占比 比较(lte)
   */
  private java.math.BigDecimal proportionOfCgTransportLte;
  /**
   * 头程占比 比较(contains)
   */
  private java.math.BigDecimal proportionOfCgTransportContains;
  /**
   * 头程占比 比较(notcontains)
   */
  private java.math.BigDecimal proportionOfCgTransportNotcontains;
  /**
   * 头程占比 比较(startswith)
   */
  private java.math.BigDecimal proportionOfCgTransportStartswith;
  /**
   * 头程占比 比较(endswith)
   */
  private java.math.BigDecimal proportionOfCgTransportEndswith;
  /**
   * 头程占比 比较(isnull)
   */
  private Boolean proportionOfCgTransportIsnull;
  /**
   * 头程占比 比较(isnotnull)
   */
  private Boolean proportionOfCgTransportIsnotnull;

  /**
   * 合计成本
   */
  private java.math.BigDecimal totalCost;

  /**
   * 最小合计成本
   */
  private java.math.BigDecimal totalCostMin;

  /**
   * 最大合计成本
   */
  private java.math.BigDecimal totalCostMax;

  /**
   * 合计成本 比较(eq)
   */
  private java.math.BigDecimal totalCostEq;
  /**
   * 合计成本 比较(neq)
   */
  private java.math.BigDecimal totalCostNeq;
  /**
   * 合计成本 比较(gt)
   */
  private java.math.BigDecimal totalCostGt;
  /**
   * 合计成本 比较(gte)
   */
  private java.math.BigDecimal totalCostGte;
  /**
   * 合计成本 比较(lt)
   */
  private java.math.BigDecimal totalCostLt;
  /**
   * 合计成本 比较(lte)
   */
  private java.math.BigDecimal totalCostLte;
  /**
   * 合计成本 比较(contains)
   */
  private java.math.BigDecimal totalCostContains;
  /**
   * 合计成本 比较(notcontains)
   */
  private java.math.BigDecimal totalCostNotcontains;
  /**
   * 合计成本 比较(startswith)
   */
  private java.math.BigDecimal totalCostStartswith;
  /**
   * 合计成本 比较(endswith)
   */
  private java.math.BigDecimal totalCostEndswith;
  /**
   * 合计成本 比较(isnull)
   */
  private Boolean totalCostIsnull;
  /**
   * 合计成本 比较(isnotnull)
   */
  private Boolean totalCostIsnotnull;

  /**
   * 合计成本占比
   */
  private java.math.BigDecimal proportionOfTotalCost;

  /**
   * 最小合计成本占比
   */
  private java.math.BigDecimal proportionOfTotalCostMin;

  /**
   * 最大合计成本占比
   */
  private java.math.BigDecimal proportionOfTotalCostMax;

  /**
   * 合计成本占比 比较(eq)
   */
  private java.math.BigDecimal proportionOfTotalCostEq;
  /**
   * 合计成本占比 比较(neq)
   */
  private java.math.BigDecimal proportionOfTotalCostNeq;
  /**
   * 合计成本占比 比较(gt)
   */
  private java.math.BigDecimal proportionOfTotalCostGt;
  /**
   * 合计成本占比 比较(gte)
   */
  private java.math.BigDecimal proportionOfTotalCostGte;
  /**
   * 合计成本占比 比较(lt)
   */
  private java.math.BigDecimal proportionOfTotalCostLt;
  /**
   * 合计成本占比 比较(lte)
   */
  private java.math.BigDecimal proportionOfTotalCostLte;
  /**
   * 合计成本占比 比较(contains)
   */
  private java.math.BigDecimal proportionOfTotalCostContains;
  /**
   * 合计成本占比 比较(notcontains)
   */
  private java.math.BigDecimal proportionOfTotalCostNotcontains;
  /**
   * 合计成本占比 比较(startswith)
   */
  private java.math.BigDecimal proportionOfTotalCostStartswith;
  /**
   * 合计成本占比 比较(endswith)
   */
  private java.math.BigDecimal proportionOfTotalCostEndswith;
  /**
   * 合计成本占比 比较(isnull)
   */
  private Boolean proportionOfTotalCostIsnull;
  /**
   * 合计成本占比 比较(isnotnull)
   */
  private Boolean proportionOfTotalCostIsnotnull;

  /**
   * 其他成本
   */
  private java.math.BigDecimal cgOtherCostsTotal;

  /**
   * 最小其他成本
   */
  private java.math.BigDecimal cgOtherCostsTotalMin;

  /**
   * 最大其他成本
   */
  private java.math.BigDecimal cgOtherCostsTotalMax;

  /**
   * 其他成本 比较(eq)
   */
  private java.math.BigDecimal cgOtherCostsTotalEq;
  /**
   * 其他成本 比较(neq)
   */
  private java.math.BigDecimal cgOtherCostsTotalNeq;
  /**
   * 其他成本 比较(gt)
   */
  private java.math.BigDecimal cgOtherCostsTotalGt;
  /**
   * 其他成本 比较(gte)
   */
  private java.math.BigDecimal cgOtherCostsTotalGte;
  /**
   * 其他成本 比较(lt)
   */
  private java.math.BigDecimal cgOtherCostsTotalLt;
  /**
   * 其他成本 比较(lte)
   */
  private java.math.BigDecimal cgOtherCostsTotalLte;
  /**
   * 其他成本 比较(contains)
   */
  private java.math.BigDecimal cgOtherCostsTotalContains;
  /**
   * 其他成本 比较(notcontains)
   */
  private java.math.BigDecimal cgOtherCostsTotalNotcontains;
  /**
   * 其他成本 比较(startswith)
   */
  private java.math.BigDecimal cgOtherCostsTotalStartswith;
  /**
   * 其他成本 比较(endswith)
   */
  private java.math.BigDecimal cgOtherCostsTotalEndswith;
  /**
   * 其他成本 比较(isnull)
   */
  private Boolean cgOtherCostsTotalIsnull;
  /**
   * 其他成本 比较(isnotnull)
   */
  private Boolean cgOtherCostsTotalIsnotnull;

  /**
   * 其他单价
   */
  private java.math.BigDecimal cgOtherUnitCosts;

  /**
   * 最小其他单价
   */
  private java.math.BigDecimal cgOtherUnitCostsMin;

  /**
   * 最大其他单价
   */
  private java.math.BigDecimal cgOtherUnitCostsMax;

  /**
   * 其他单价 比较(eq)
   */
  private java.math.BigDecimal cgOtherUnitCostsEq;
  /**
   * 其他单价 比较(neq)
   */
  private java.math.BigDecimal cgOtherUnitCostsNeq;
  /**
   * 其他单价 比较(gt)
   */
  private java.math.BigDecimal cgOtherUnitCostsGt;
  /**
   * 其他单价 比较(gte)
   */
  private java.math.BigDecimal cgOtherUnitCostsGte;
  /**
   * 其他单价 比较(lt)
   */
  private java.math.BigDecimal cgOtherUnitCostsLt;
  /**
   * 其他单价 比较(lte)
   */
  private java.math.BigDecimal cgOtherUnitCostsLte;
  /**
   * 其他单价 比较(contains)
   */
  private java.math.BigDecimal cgOtherUnitCostsContains;
  /**
   * 其他单价 比较(notcontains)
   */
  private java.math.BigDecimal cgOtherUnitCostsNotcontains;
  /**
   * 其他单价 比较(startswith)
   */
  private java.math.BigDecimal cgOtherUnitCostsStartswith;
  /**
   * 其他单价 比较(endswith)
   */
  private java.math.BigDecimal cgOtherUnitCostsEndswith;
  /**
   * 其他单价 比较(isnull)
   */
  private Boolean cgOtherUnitCostsIsnull;
  /**
   * 其他单价 比较(isnotnull)
   */
  private Boolean cgOtherUnitCostsIsnotnull;

  /**
   * 是否有其他成本明细
   */
  private Integer hasCgOtherCostsDetail;

  /**
   * 最小是否有其他成本明细
   */
  private Integer hasCgOtherCostsDetailMin;

  /**
   * 最大是否有其他成本明细
   */
  private Integer hasCgOtherCostsDetailMax;

  /**
   * 是否有其他成本明细 比较(eq)
   */
  private Integer hasCgOtherCostsDetailEq;
  /**
   * 是否有其他成本明细 比较(neq)
   */
  private Integer hasCgOtherCostsDetailNeq;
  /**
   * 是否有其他成本明细 比较(gt)
   */
  private Integer hasCgOtherCostsDetailGt;
  /**
   * 是否有其他成本明细 比较(gte)
   */
  private Integer hasCgOtherCostsDetailGte;
  /**
   * 是否有其他成本明细 比较(lt)
   */
  private Integer hasCgOtherCostsDetailLt;
  /**
   * 是否有其他成本明细 比较(lte)
   */
  private Integer hasCgOtherCostsDetailLte;
  /**
   * 是否有其他成本明细 比较(contains)
   */
  private Integer hasCgOtherCostsDetailContains;
  /**
   * 是否有其他成本明细 比较(notcontains)
   */
  private Integer hasCgOtherCostsDetailNotcontains;
  /**
   * 是否有其他成本明细 比较(startswith)
   */
  private Integer hasCgOtherCostsDetailStartswith;
  /**
   * 是否有其他成本明细 比较(endswith)
   */
  private Integer hasCgOtherCostsDetailEndswith;
  /**
   * 是否有其他成本明细 比较(isnull)
   */
  private Boolean hasCgOtherCostsDetailIsnull;
  /**
   * 是否有其他成本明细 比较(isnotnull)
   */
  private Boolean hasCgOtherCostsDetailIsnotnull;

  /**
   * 其他成本占比
   */
  private java.math.BigDecimal proportionOfCgOtherCosts;

  /**
   * 最小其他成本占比
   */
  private java.math.BigDecimal proportionOfCgOtherCostsMin;

  /**
   * 最大其他成本占比
   */
  private java.math.BigDecimal proportionOfCgOtherCostsMax;

  /**
   * 其他成本占比 比较(eq)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsEq;
  /**
   * 其他成本占比 比较(neq)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsNeq;
  /**
   * 其他成本占比 比较(gt)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsGt;
  /**
   * 其他成本占比 比较(gte)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsGte;
  /**
   * 其他成本占比 比较(lt)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsLt;
  /**
   * 其他成本占比 比较(lte)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsLte;
  /**
   * 其他成本占比 比较(contains)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsContains;
  /**
   * 其他成本占比 比较(notcontains)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsNotcontains;
  /**
   * 其他成本占比 比较(startswith)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsStartswith;
  /**
   * 其他成本占比 比较(endswith)
   */
  private java.math.BigDecimal proportionOfCgOtherCostsEndswith;
  /**
   * 其他成本占比 比较(isnull)
   */
  private Boolean proportionOfCgOtherCostsIsnull;
  /**
   * 其他成本占比 比较(isnotnull)
   */
  private Boolean proportionOfCgOtherCostsIsnotnull;

  /**
   * 毛利润
   */
  private java.math.BigDecimal grossProfit;

  /**
   * 最小毛利润
   */
  private java.math.BigDecimal grossProfitMin;

  /**
   * 最大毛利润
   */
  private java.math.BigDecimal grossProfitMax;

  /**
   * 毛利润 比较(eq)
   */
  private java.math.BigDecimal grossProfitEq;
  /**
   * 毛利润 比较(neq)
   */
  private java.math.BigDecimal grossProfitNeq;
  /**
   * 毛利润 比较(gt)
   */
  private java.math.BigDecimal grossProfitGt;
  /**
   * 毛利润 比较(gte)
   */
  private java.math.BigDecimal grossProfitGte;
  /**
   * 毛利润 比较(lt)
   */
  private java.math.BigDecimal grossProfitLt;
  /**
   * 毛利润 比较(lte)
   */
  private java.math.BigDecimal grossProfitLte;
  /**
   * 毛利润 比较(contains)
   */
  private java.math.BigDecimal grossProfitContains;
  /**
   * 毛利润 比较(notcontains)
   */
  private java.math.BigDecimal grossProfitNotcontains;
  /**
   * 毛利润 比较(startswith)
   */
  private java.math.BigDecimal grossProfitStartswith;
  /**
   * 毛利润 比较(endswith)
   */
  private java.math.BigDecimal grossProfitEndswith;
  /**
   * 毛利润 比较(isnull)
   */
  private Boolean grossProfitIsnull;
  /**
   * 毛利润 比较(isnotnull)
   */
  private Boolean grossProfitIsnotnull;

  /**
   * 毛利率
   */
  private java.math.BigDecimal grossRate;

  /**
   * 最小毛利率
   */
  private java.math.BigDecimal grossRateMin;

  /**
   * 最大毛利率
   */
  private java.math.BigDecimal grossRateMax;

  /**
   * 毛利率 比较(eq)
   */
  private java.math.BigDecimal grossRateEq;
  /**
   * 毛利率 比较(neq)
   */
  private java.math.BigDecimal grossRateNeq;
  /**
   * 毛利率 比较(gt)
   */
  private java.math.BigDecimal grossRateGt;
  /**
   * 毛利率 比较(gte)
   */
  private java.math.BigDecimal grossRateGte;
  /**
   * 毛利率 比较(lt)
   */
  private java.math.BigDecimal grossRateLt;
  /**
   * 毛利率 比较(lte)
   */
  private java.math.BigDecimal grossRateLte;
  /**
   * 毛利率 比较(contains)
   */
  private java.math.BigDecimal grossRateContains;
  /**
   * 毛利率 比较(notcontains)
   */
  private java.math.BigDecimal grossRateNotcontains;
  /**
   * 毛利率 比较(startswith)
   */
  private java.math.BigDecimal grossRateStartswith;
  /**
   * 毛利率 比较(endswith)
   */
  private java.math.BigDecimal grossRateEndswith;
  /**
   * 毛利率 比较(isnull)
   */
  private Boolean grossRateIsnull;
  /**
   * 毛利率 比较(isnotnull)
   */
  private Boolean grossRateIsnotnull;

  /**
   * 店铺id
   */
  private Integer sid;

  /**
   * 最小店铺id
   */
  private Integer sidMin;

  /**
   * 最大店铺id
   */
  private Integer sidMax;

  /**
   * 店铺id 比较(eq)
   */
  private Integer sidEq;
  /**
   * 店铺id 比较(neq)
   */
  private Integer sidNeq;
  /**
   * 店铺id 比较(gt)
   */
  private Integer sidGt;
  /**
   * 店铺id 比较(gte)
   */
  private Integer sidGte;
  /**
   * 店铺id 比较(lt)
   */
  private Integer sidLt;
  /**
   * 店铺id 比较(lte)
   */
  private Integer sidLte;
  /**
   * 店铺id 比较(contains)
   */
  private Integer sidContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private Integer sidNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private Integer sidStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private Integer sidEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 币种(模糊搜索)
   */
  private String currencyCode;

  /**
   * 币种 比较(eq)
   */
  private String currencyCodeEq;
  /**
   * 币种 比较(neq)
   */
  private String currencyCodeNeq;
  /**
   * 币种 比较(gt)
   */
  private String currencyCodeGt;
  /**
   * 币种 比较(gte)
   */
  private String currencyCodeGte;
  /**
   * 币种 比较(lt)
   */
  private String currencyCodeLt;
  /**
   * 币种 比较(lte)
   */
  private String currencyCodeLte;
  /**
   * 币种 比较(contains)
   */
  private String currencyCodeContains;
  /**
   * 币种 比较(notcontains)
   */
  private String currencyCodeNotcontains;
  /**
   * 币种 比较(startswith)
   */
  private String currencyCodeStartswith;
  /**
   * 币种 比较(endswith)
   */
  private String currencyCodeEndswith;
  /**
   * 币种 比较(isnull)
   */
  private Boolean currencyCodeIsnull;
  /**
   * 币种 比较(isnotnull)
   */
  private Boolean currencyCodeIsnotnull;

  /**
   * 币种符号(模糊搜索)
   */
  private String currencyIcon;

  /**
   * 币种符号 比较(eq)
   */
  private String currencyIconEq;
  /**
   * 币种符号 比较(neq)
   */
  private String currencyIconNeq;
  /**
   * 币种符号 比较(gt)
   */
  private String currencyIconGt;
  /**
   * 币种符号 比较(gte)
   */
  private String currencyIconGte;
  /**
   * 币种符号 比较(lt)
   */
  private String currencyIconLt;
  /**
   * 币种符号 比较(lte)
   */
  private String currencyIconLte;
  /**
   * 币种符号 比较(contains)
   */
  private String currencyIconContains;
  /**
   * 币种符号 比较(notcontains)
   */
  private String currencyIconNotcontains;
  /**
   * 币种符号 比较(startswith)
   */
  private String currencyIconStartswith;
  /**
   * 币种符号 比较(endswith)
   */
  private String currencyIconEndswith;
  /**
   * 币种符号 比较(isnull)
   */
  private Boolean currencyIconIsnull;
  /**
   * 币种符号 比较(isnotnull)
   */
  private Boolean currencyIconIsnotnull;

  /**
   * 表单名称
   */
  private String formNames;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
